Abstraction in object-oriented programming

Inheritance and polymorphism in object-oriented programming

Encapsulation in object-oriented programming

Profile code to identify issues

Job preparation: Junior Programmer

Quiz: Apply object-oriented principles

Submission: Programming theory in action

Deep-dive into the pillars of object-oriented programming and their application, then learn how to profile and optimize code.

In this mission, you’ll refactor the inventory project you completed in the previous mission using the pillars of object-oriented programming as a guide. You’ll deep dive into the inner workings of each pillar individually, so you can better understand its value in developing applications. Next, you’ll learn how to profile your code to identify any optimization bottlenecks that would slow down the final build of your application. To close out this mission, you’ll develop a small application for your portfolio that uses fully optimized code built on OOP principles. 

When you complete this mission you will complete the Junior Programmer pathway - CONGRATULATIONS!

Apply Object-Oriented Principles

Unity Junior Programmer

Kickstart your programming career with Unity's Junior Programmer Pathway. Learn coding fundamentals, C#, and game development to create your first interactive projects. Start learning for free!

Junior Programmer Pathway - Learn Coding & Game Development | Unity Learn

We recommend that you have basic knowledge of Unity or complete 

Ready to code? This guided learning Pathway will take you from zero to job-ready!

Welcome to Junior Programmer! Designed for anyone interested in learning to code or obtaining an entry-level Unity role, this pathway assumes a basic knowledge of Unity and has no math prerequisites. Junior Programmer prepares you to get Unity Certified so that you can demonstrate your job-readiness to employers.

Junior Programmer

Course Introduction

Install Unity Software

Unit 1 - Introduction

Lesson 1.1 - Start your 3D Engines 

Lesson 1.2 - Pedal to the Metal

Lesson 1.3 - High Speed Chase

Lesson 1.4 - Step into the Driver's Seat

Challenge 1 - Plane Programming

Lab 1 - Project Design Document

Introduction to project management and teamwork

Quiz 1

Learn how to create new C# scripts, call basic functions, and use variables to modify the results of those functions.

In this first mission in the Junior Programmer pathway, you will program a car moving side-to-side on a floating road, trying to avoid (or hit) obstacles in the way. In addition to becoming familiar with the Unity editor and workflow, you will learn how to create new C# scripts and do some simple programming. By the end of the Unit, you will be able to call basic functions, then declare and tweak new variables to modify the results of those functions.

Player Control

Unit 2 - Introduction

Lesson 2.1 - Player Positioning

Lesson 2.2 - Food Flight

Lesson 2.3 - Random Animal Stampede

Lesson 2.4 - Collision Decisions

Challenge 2 - Play Fetch

Lab 2 - New Project with Primitives

Quiz 2

Mod the Cube

Quiz: Create with Code 1

Gain familiarity with some of the most important programming and Unity concepts, including if-then statements, random value generation, arrays, collision detection, prefabs, and instantiation.

In this Mission, you will program a top-down game with the objective of throwing food to hungry animals - who are stampeding towards you - before they can run past you. In order to do this, you will become much more familiar with some of the most important programming and Unity concepts, including if-then statements, random value generation, arrays, collision detection, prefabs, and instantiation. In completing this Unit, you will learn how to program a basic game with the ability to launch projectiles and maneuver the player to keep the game alive.

Basic Gameplay

Unit 3 - Introduction

Lesson 3.1 - Jump Force

Lesson 3.2 - Make the World Whiz By

Lesson 3.3 - Don't Just Stand There

Lesson 3.4 - Particles and Sound Effects

Challenge 3 - Balloons, Bombs, & Booleans

Lab 3 - Player Control

Quiz 3

Learn how to add music, sound effects, and visual particle effects to transform the experience of your project.

In this Mission, you will program a fast-paced endless side-scrolling runner game where the player needs to time jumps over oncoming obstacles to avoid crashing. In creating this prototype, you will learn how to add music and sound effects, completely transforming the experience of your projects. You will also learn how to create dynamic endless repeating backgrounds, which are critical for any side-scrolling games. Finally, you will learn to incorporate particle effects like splatters and explosions, which make your games so much more satisfying to play.

Sound and Effects

Unit 4 - Introduction

Lesson 4.1 - Watch Where You’re Going

Lesson 4.2 - Follow the Player

Lesson 4.3 - PowerUp and CountDown

Lesson 4.4 - For-Loops For Waves

Challenge 4 - Soccer Scripting

Lab 4 - Basic Gameplay

Quiz 4

Learn how to implement new gameplay mechanics including powerups and increasing difficulty.

In this Mission, you will program an arcade-style Sumo battle with the objective of knocking increasingly difficult waves of enemies off of a floating island, using power ups to help defeat them. In creating this prototype, you will learn how to implement new gameplay mechanics into your projects, which are new rules or systems that make the game more interesting to play. On one hand, you will learn to program a powerup, which give the player a temporary advantage. On the other hand, you will learn to program increasingly difficult enemy waves, which make survival more challenging for the player. A good balance of powerups and increasing difficulty make for a much more interesting gameplay experience.

Gameplay Mechanics

Unit 5 - Introduction

Lesson 5.1 - Clicky Mouse

Lesson 5.2 - Keeping Score

Lesson 5.3 - Game Over

Lesson 5.4 - What’s the Difficulty?

Challenge 5 - Whack-a-Food

Lab 5 - Swap out your Assets

Quiz 5

Introduction to user feedback and testing

Learn how to implement a User Interface - or UI - into your projects, such as a title screen and score display.

In this Mission, you will program a game to test the player’s reflexes, where the goal is to click and destroy objects randomly tossed in the air before they can fall off the screen. In creating this prototype, you will learn how to implement a User Interface - or UI - into your projects. You will add a title screen with a difficulty select menu that will control how challenging the gameplay is, you will add a score display that will track how many points the player has earned, and you will add a Game Over screen, which will allow the player to restart and try again. In learning these skills, you will be able to create a fully “playable” experience that the user can enjoy from start to finish without having to restart the application to try it again.

User Interface

Next Steps - Introduction

Lesson 6.1 - Project Optimization

Lesson 6.2 - Research and Troubleshooting

Lesson 6.3 - Sharing your Projects

ECS Survival Guide

Career research and preparation

Introduction to portfolios

Debug the App

Counting Prototype

Quiz: Create with Code 2

Prepare to continue developing your Unity and C# skills independently, including learning how to complete your personal project.

In this Mission, you'll prepare to continue developing your Unity and C# skills independently, including learning how to complete your personal project and how to prepare for the Unity Certified User: Programming exam, which you can take through your school program, if available.

Publishing Your Project

Introduction to real-time 3D experience design

Set up version control

Explore the sample project

Principles of object-oriented programming

Create a scene flow

Implement data persistence between scenes

Implement data persistence between sessions

Quiz: Manage scene flow and data

Submission: Data persistence in a new repo

Learn about data persistence and an introduction to the core pillars of object-oriented programming.

In this mission, you’ll learn about data persistence, or how to manage the loading and unloading of data between both scenes and sessions. Along the way, you will be introduced to the core pillars of object-oriented programming, which will help you structure your code throughout the mission. There will only be one practical example throughout the mission, which will build on the new functionality you create with each tutorial. At the end of this mission, you’ll take everything you learned and apply it to a new project by building a persistent score system for a small game.

Manage Scene Flow and Data

c5d38f44-30c7-4b12-ad89-7486c17e4b78:de14d1bdd753

Overview

What is encapsulation?

Private variables and Inspector visibility

Find a vulnerable public variable in your project

Create a Property with a Getter and a Setter

Locate the need for setter validation

Make a property with a backing field

Implement setter validation to prevent negative numbers

Summary

In this tutorial, you’ll learn about the second pillar in object-oriented programming: encapsulation.

Explain how encapsulation is used to write code that can only be used as intended by the programmer

Control access to data within a class by applying encapsulation with getters and setters

Obj-Prog-WIC-3.3: Differentiate between public variables (properties), private variables (fields), and local variables.

Enable easier readability and debugging by correctly organizing classes to include only singular purpose code

Junior Programmer: Apply object-oriented principles

Much like abstraction, encapsulation focuses heavily on maintaining a level of separation between the underlying complexity of your code and other code that uses it. Due to their similarity, you will sometimes see some followers of OOP practices group abstraction and encapsulation into a single pillar, typically under the header of encapsulation. However, we’re making a distinction that we think is important: while abstraction is all about summarizing code to make it simpler for other programmers, encapsulation is all about protecting values and data, as if they are enclosed in a capsule, so that you control what others do and do not have access to.  

A major theme of encapsulation is safety in code — in other words, the process of ensuring that code is only used as it is intended to be used, and the values and data you are manipulating can’t be corrupted. In encapsulated code, other programmers can’t easily change the values of variables or the properties of objects. It’s impossible to account for all of the different ways that other scripts might access your code, so it's far better to encapsulate what you’ve created so it can only perform as intended. 

Let’s take a look at a situation where you used encapsulation during Create with Code, all the way back in Unit 1 - Player Control. The following were variables used to control a vehicle driving down the road.

public float speed = 20.0f;
public float turnSpeed = 45.0f;
public float horizontalInput;
public float forwardInput;

When you first wrote this code, you set all of your variables to be public so you could see how they updated in the Inspector during Play mode. Since you were new to programming at the time, it helped you better understand how the changing values of your variables modified your gameplay. Making your variables public also allowed you to fine-tune the vehicle’s movement by testing your speed and turnSpeed values in real time. 

Once you settled on your final numbers, you made your variables private as a means of “locking in” their values.

// all variables now private instead of public
private float speed = 20.0f;
private float turnSpeed = 45.0f;
private float horizontalInput;
private float forwardInput;

You no longer wanted anyone to be able to easily — perhaps accidentally — change the inputs that you settled on. As simple as it was, this was your first experience with encapsulation. 

Accessibility of variables and methods is a major consideration in encapsulation. As a general rule, you want to keep your variables private as often as possible, and set methods to public only when you’re sure that you need to call them from anywhere. Otherwise, they can be used by anyone. 

When you’re working on a small project by yourself, encapsulation might not seem important — in fact, making everything public might even seem convenient. However, if you’re working with others, or if others will work on your code later, unexpected problems can easily arise if variables and methods are used when they really shouldn’t be. 

Image of four pillars in a row, labeled from left to right with Abstraction, Inheritance, Polymorphism and Encapsulation. The fourth pillar labeled Encapsulation is highlighted.

Image of gameplay from the “Driving Simulation” prototype made in Create with Code Unit 1. It shows a blue vehicle turning on a road after crashing into a crate.

Making a variable public exposes it to the Inspector, but it also makes it available to be changed in any other method of your application. Good news — there is a way to make values available in the Inspector, otherwise known as serialized, without exposing them to other code. This gives you the freedom of modifying variables in the inspector, while still keeping them safe. In fact, the access modifier of a variable (public, private), actually doesn’t control serialization — but public variables are serialized by default. You can easily expose your private variables in the Inspector by adding the [SerializeField] tag. 

public class Rabbit : MonoBehaviour 
{
    [SerializeField] // exposes private variables in the inspector
    private Color furColor;
}

Rabbit component shown in the Inspector with the Fur Color property available for edit.

It would be easy to make all your variables private to protect values from misuse, but what about variables that really need to be public? How do you protect them? Let’s work through an example in our project.

In MainManager.cs, you added the following public variable:

You can’t make this variable private because it would cause errors in the other scripts that need access to it, but leaving it public means it’s vulnerable to potential misuse. Let’s cause some mischief to demonstrate the problem:

1.  For experimental purposes, in MenuUIHandler.cs, add a line of code at the end of the Start() method that sets the MainManager instance to null. 

2.  Test your application by selecting the color selection buttons. You will now get a Null Reference Exception in the Console.  

We need some way of preventing this kind of misuse, while still granting public access to the variable.  

Game view of the Warehouse project menu scene with the blue color selected next to the Console window, which is displaying a Null Reference Exception error.

Essentially, what we want to do is make the variable “read-only,” allowing other classes to get the value, but not set the value. In order to do this, we can use the C# get and set methods, which will control how and when our variable can be used.  

1.  In MainManager.cs, add a get accessor to the end of your MainManager Instance variable: 

public static MainManager Instance { get; } // add getter to the end of the line

As soon as you add a get or set accessor to a variable, that variable becomes a Property — a special kind of variable that provides access to internal data through these specialized methods. 

2.  Without a set accessor, this property is strictly read-only —its value cannot be set anywhere. Because of that, there is now an error on that mischievous line of code you added earlier in MenuUIHandler.cs. That’s good — we don’t want any other class to be able to reset it — so you can now delete that line of code.  

// MainManager.Instance = null; - delete or comment out this line of code

3.  However, there is still a problem: since the property is strictly read-only, it can’t even be set in its own class, which is causing an error lower down in MainManager.cs on the line Instance = this;. To fix this, add a private setter to the property, which should resolve that error: 

public static MainManager Instance { get; private set; } // add private setter

With this code, you can now set the property’s value from within the class, but only get it from outside the class. It’s encapsulated to only accept modifications from its own class, safe from misuse and corruption from the outside world!  

The getter and setter you added above represent the most basic form of encapsulation, where you are simply getting or setting the value — nothing fancy. This simple implementation is called an auto-implemented property.  

But in addition to restricting if or where a value can be set, you might also want to restrict how a value can be set in a more customized, manual way. For example, in an application that allows another class to set the date, you might restrict the month to a number between 1 and 12. Or you might want to prevent the use of negative numbers. 

In our warehouse project, there’s a place where we can do precisely that: we have a Production Speed variable that should never be set to a negative number. 

1. In ResourcePile.cs, locate the exposed public ProductionSpeed variable. 

Also locate the line in ProductivityUnit.cs where that public variable is multiplied by a constant. 

m_CurrentPile.ProductionSpeed *= ProductivityMultiplier;

There’s nothing stopping us, a future version of ourselves, or some other carefree developer from setting this to a negative number, which would cause problems for this project.

2.  For experimental purposes, mischievously modify this line of code to subtract from the production speed instead of multiplying it. 

m_CurrentPile.ProductionSpeed -= ProductivityMultiplier; // replace '*=' with '-='

Then test your application and use the Productivity Unit to produce a negative result: 

What we need is a custom setter, which can make sure this variable is never set to a negative value.  

User interface display popup from the Main warehouse scene displaying the message, “Resource Type 2 Producing at the speed of -1.5/s.”

To perform validations or calculations within a getter or setter, you need a backing field for your property: a private field (variable) that stores the data exposed by the public property. 

1. In ResourcePile.cs, add a private member variable (backing field), using the same name as ProductionSpeed, but store the value in this new private field instead: 

private float m_ProductionSpeed = 0.5f; // add new private backing field
public float ProductionSpeed; // remove value from public property

2.  With the backing field declared, you can now manually add the get and set functions, which retrieve or assign the backing field when someone accesses the public property. 

private float m_ProductionSpeed = 0.5f;
public float ProductionSpeed // delete semicolon
{
    get { return m_ProductionSpeed; } // getter returns backing field
    set { m_ProductionSpeed = value; } // setter uses backing field
}

Since these are not going to be simple get and set methods, it’s not possible to use the “{ get; set; }” shorthand we used with the auto-implemented property earlier. 

Instead, we are doing it manually. When someone gets the ProductionSpeed property, it will return the backing field. When someone sets the ProductionSpeed property, the backing field is set to the value they’ve entered.

3.  Then, since the data is now stored in the backing field rather than the public property, references to the property should be swapped with the private field. In ResourcePile.cs, replace the two references to ProductionSpeed with m_ProductionSpeed. 

...
m_CurrentProduction += m_ProductionSpeed * Time.deltaTime; // swap in m_ version
...
return $"Producing at the speed of {m_ProductionSpeed}/s"; // swap in m_ version

Now, whenever someone tries to get or set the public property, it accesses the backing field encapsulated in the class through the getter and setter. However, we still haven’t actually implemented the setter validation, so that negative number is still possible! We’ll fix that right now. 

Finally, with everything configured, we can now implement a validation check within the set method, ensuring the Production Speed is always a positive number. In fact, we can even display a warning message in the console if a negative number is attempted.

1.  Within the set method, add an if-else statement that displays a warning message if the value is negative, but successfully sets the value if it’s positive. 

set
{
    if (value < 0.0f)
    {
        Debug.LogError("You can't set a negative production speed!");
    }
    else
    {
        m_ProductionSpeed = value; // original setter now in if/else statement
    }
}

2.  Test your application again and see what happens when the production speed is set to a negative number. It should display the error message. 

3.  With the setter validation fully implemented and tested, you can now return the ProductivityUnit to function as normal with a multiplication rather than a subtraction operator. 

m_CurrentPile.ProductionSpeed *= ProductivityMultiplier; // revert '-=' to '*='

Game view of Main warehouse scene next to the Console window, which is displaying the error message, “You can’t set a negative production speed!”

Encapsulation protects your code by controlling the ways values are accessed and changed, so that your code is only used as explicitly designed. Like abstraction, encapsulation places a layer of separation between the underlying complexity of your code and the programmers who might be accessing it. 

In the project, you used an auto-implemented property to make a variable read-only to external classes. Then, you wrote a getter and setter for a property with a backing field to prevent it from being set to a negative number. You can now sleep soundly in the knowledge that both of these pieces of data are encapsulated, protected from mischief or misuse.  

Encapsulation in object-oriented programming

1. Overview

2. What is encapsulation?

3. Private variables and Inspector visibility

4. Find a vulnerable public variable in your project

5. Create a Property with a Getter and a Setter

6. Locate the need for setter validation

7. Make a property with a backing field

8. Implement setter validation to prevent negative numbers

9. Summary

Complete this tutorial