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

dec47fd0-8f21-45da-ae24-4c70f40bde44:45defd4a9469

Overview

What is inheritance?

What is polymorphism?

Create a new unit type

Override the BuildingInRange method

Understand Overloads

Override the GoTo methods

Summary

Warehouse-productivity-unit.mp4

In this tutorial, you’ll learn about inheritance and polymorphism, two closely related pillars of OOP.


Explain how inheritance is used to share functionality between a parent and child class

Define the relationship between a parent and child class, including what a child class can and cannot do with respect to its parent class. 

Recognize opportunities where inheritance could be used to simplify code.

Describe how polymorphism is used to modify parent class functionality in a child class

Describe how polymorphism can be applied at compile time (method overloads) and run time (method overrides).

Recommend a high-level system architecture for a given project

Junior Programmer: Apply object-oriented principles

The next two pillars of object-oriented programming, inheritance and polymorphism, are deeply intertwined. Inheritance, much like the name implies, focuses on parent-child relationships between different objects. Polymorphism is a result of inheritance, and refers to the process of a child class modifying what it inherits from a parent class. Used together, inheritance and polymorphism can reduce the amount of code you have to write in an application. 

Inheritance is the process of creating a primary class (also known as a parent class) from which other classes (called child classes) can be created. A child class takes on, or inherits, all of the features of the parent class automatically. It’s common to have different classes share similar features in an application. For example, a video game may feature many different types of enemy classes, but they are likely to share the same core features, such as managing their own health and the ability to deal damage to the player. With inheritance, the need to write that health and damage functionality for each individual enemy class is eliminated, so that you can focus on writing functionality that’s unique to each class. 

You’ve already been making use of inheritance with every script you’ve written in Unity so far. By default, whenever you create a new class, it inherits from MonoBehaviour: 

public class SomeClass : MonoBehaviour { }

MonoBehaviour is the base class from which all core Unity scripting functionality inherits. Without MonoBehaviour, you wouldn’t be able to call OnTriggerEnter, GetComponent, or even use Start or Update! 

In the diagram above, it might appear that all of the child enemy classes would lose their ability to access Unity functionality, because they exchanged their inheriting class from MonoBehaviour to Enemy. Fortunately, since the Enemy class inherits from Monobehaviour, the children of the Enemy class are also considered children of MonoBehaviour!

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

Flow chart showing the relationship between parent classes and child classes. Enemy class is at the top of the diagram with arrows pointing downward to three child classes: Thief class, Scoundrel class, and Self-identifying ‘bad guy’ class. Both parent and child classes have the shared behaviors of “deal damage” and “reduce health”, but each child class also has a unique behavior not shared by the parent or the other child classes

Although inheriting core functionality from a parent class can be helpful, there are many situations where you don’t want the child class to perform exactly the same action as the parent class. Polymorphism allows you to change the functionality of what an object inherits from its parent class. 

public class Enemy : MonoBehaviour 
{ 
    public void DealDamage () 
    {
        Player.Health -= 10;
    }
}

In the above example, the Enemy class has a DealDamage method that removes 10 points from the Player’s health whenever it’s called. The Thief class, a child of Enemy, can call this method without declaring it in the class. 

public class Thief : Enemy
{
    private void Update()
    {
        if (Player.isSeen)
        {
            DealDamage(); // method from parent class can be called
        }
    }
}

This is fine if you want the Thief to deal exactly the same amount of damage as the Enemy class, but what if you wanted it to be a different value? These changes are accomplished through the process known as method overriding. 

The method that you want to override in the parent class must first be marked for overriding. This is done by making it a virtual method: 

public class Enemy : MonoBehaviour { 

    public virtual void DealDamage () { // virtual keyword allows overriding

        Player.Health -= 10;
    }
}

Identifying a method as virtual indicates that it can, but doesn’t have to, be overridden. This is ideal for the current example, because while the Thief child class may need to modify the DealDamage method, another child class, such as the Scoundrel class, may not.

Once DealDamage is set to virtual, the Thief class can override it by creating its own  method for DealDamage. Here, instead of virtual, we’ll use the override notation. You can now add new functionality into the method specifically for the Thief class: 

public class Thief : Enemy
{
    public override void DealDamage() // can override virtual methods from parent class
    {
        Player.Health -= 2;
        CommitPettyTheft();
    }
    private void Update()
    {
        if (Player.isSeen)
        {
            DealDamage();
        }
    }
}

The Thief class now deals a smaller amount of damage than the parent Enemy class, and also calls one of the Thief-specific methods. Now, when DealDamage is called in Update by a Thief object, the customized DealDamage method will be called instead of the parent method. 

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

In the project brief, you’ll see that one of the items to be built is a productivity unit. This unit should increase the productivity of any resource type that the user has selected in the scene. The user will select the resource the same way as the forklift: left-click to select the unit, and right-click to select the resource to move to. The productivity of a resource should only be increased while the productivity unit is actively working on it, and if the unit leaves the resource, it should return to a normal production rate. 

Here’s what that might look like in your project:

The forklift is managed by the TransporterUnit script, which itself is a child of the Unit class. If you look at the Unit class, you’ll see that all of the functionality we need for movement is there, so it makes sense that our productivity unit should become another child class of Unit.

1. In the Prefabs folder, locate the ProductivityUnit Prefab and add it to the scene. This is the worker that will improve the quality of your resource piles! 

2. Create a new MonoBehaviour script and name it ProductivityUnit.

3. Double-click to open it in Visual Studio. Delete the Start and Update methods.

4. To make the ProductivityUnit class inherit from Unit, remove MonoBehaviour from the class declaration and replace it with Unit. 

public class ProductivityUnit : Unit // replace MonoBehaviour with Unit
{

}

An error will appear in your script that says: ‘ProductivityUnit’ does not implement inherited abstract member ‘Unit.BuildingInRange()’. Don’t worry – we’ll fix this right now. 

5.  If you look in Unit.cs, you will see the following code:

protected abstract void BuildingInRange();

Unlike virtual methods for which overriding is optional, this method uses the abstract notation, which indicates that it must be overridden. Abstract methods are useful when you recognize that all child classes will need a certain type of functionality, but that functionality should be coded separately in each child class. In this case, BuildingInRange is meant to manage everything that happens when a unit is interacting with a resource pile (which is a child of the building class), but what occurs will change based on which child class calling the method.

So, back in ProductivityUnit.cs, all you need to do is override that method:

protected override void BuildingInRange()
{
    
}

6. With that error resolved, let’s explore the functionality we automatically gain by simply extending the Unit class. Save the ProductivityUnit script and return to Unity. 

7. Add the ProductivityUnit script to the Prefab. Notice that because the class is a child of Unit, it’s automatically given a public float variable to control its speed. 

8. Press Play. Left-click on your new worker and then right-click on one of the resource piles. Your worker will navigate to the resource pile automatically. If you right-click elsewhere in the scene, it will move there as well. All of this is accomplished without writing a single additional line of code in the ProductivityUnit class — all current functionality has been inherited from Unit. 

Close-up in Scene view of the “ProductivityUnit Prefab,” which is a worker who has his arms extended out to his side in t-pose.

Productivity Unit component showing the Speed property set to 3.

The main feature of the productivity unit is to increase the production rate of the resource pile it's currently assigned to. Let’s build out that functionality.

1.  To complete the BuildingInRange method, you’ll need a variable that will keep track of any resource pile that the user has selected. At the top of the class, create a ResourcePile variable named m_CurrentPile and set it to null. You’ll also need a float that will define by what amount the resource productivity should be increased:
 

public class ProductivityUnit : Unit
{
    // new variables
    private ResourcePile m_CurrentPile = null;
    public float ProductivityMultiplier = 2;

2. Return to the BuildingInRange method to code what happens when the productivity unit is in range of a resource pile. This code will run every frame. We want the production speed to increase during the frame when the productivity unit comes within range of a Building that is a resource pile. Then we want to prevent this code from running in the next frames, or else the production speed will keep increasing! 

protected override void BuildingInRange()
{
    // start of new code
    if (m_CurrentPile == null)
    {
        ResourcePile pile = m_Target as ResourcePile;

        if (pile != null)
        {
            m_CurrentPile = pile;
            m_CurrentPile.ProductionSpeed *=  ProductivityMultiplier;
        }
    }
    // end of new code
}

The notation “as ResourcePile” sets the pile variable to m_Target only if m_Target is a ResourcePile type. If m_Target is a Base, these types won’t match, and pile will be set to null. This is an efficient way of checking whether m_Target is a resource pile. If it is (pile != null), then m_CurrentPile is set to that resource pile, and its ProductionSpeed is doubled.

On the next frame, the if statement at the top of the method will prevent this code from running again, because m_CurrentPile will be set to a value (the resource pile).

One other interesting thing to note in this code is that you were able to access the m_Target variable, which is a “protected” variable in the parent Unit class. Protected variables are like private variables, but they can also be accessed by any child classes — you were only able to access it because ProductivityUnit.cs derives from Unit.cs.

4.  Press Play and send your worker to a resource pile.

5.  Select the resource pile before the productivity unit arrives, and note that the production rate doubles once it does.

To finalize the productivity unit, you need to make the resource pile’s production rate return to its previous value as soon as the unit leaves, as is described in the brief. In the Unit class, this is managed by the GoTo method — but if you look at the class, you’ll notice that there are not one, but two methods that have this name: 

public virtual void GoTo(Building target)
{
    m_Target = target;

    if (m_Target != null)
    {
        m_Agent.SetDestination(m_Target.transform.position);
        m_Agent.isStopped = false;
    }
}

public virtual void GoTo(Vector3 position)
{
    m_Target = null;
    m_Agent.SetDestination(position);
    m_Agent.isStopped = false;
}

Methods can’t share names — right? In most cases this is true, except for this special circumstance, which is referred to as method overloading. Notice that the both GoTo methods have different parameter types, and have different functionality. Method overloading effectively makes a single method multi-purpose. When the user selects a target, this pair of overloads will handle the navigation depending on the type of object they selected. 

The first GoTo method takes a Building class as a parameter, which is collected when the user right-clicks on a resource pile or on the base. This parameter is then passed to the SetTarget method in the Unit script. 

The second GoTo method takes a Vector3 parameter, for situations when the user selects a random point in the warehouse rather than a resource pile. 

You could write these as separate methods, but then you’d have to remember multiple calls! With method overloading, you only have to remember one call, and the data type(s) being passed will determine which code to run.. 

This is yet another feature you have seen in Unity’s built-in methods. Whenever you call a method from the Unity API and have many options for parameters to use, you’re taking advantage of method overloading. For example, transform.Translate has four separate overloads, a few of which you used during the first unit of Create with Code to get a car moving down a road:

public void Translate(Vector3 translation); 
// implemented as transform.Translate(Vector3.forward);

public void Translate(float x, float y, float z); 
// implemented as transform.Translate(0, 0, 1);

public void Translate(Vector3 translation, Transform relativeTo);
// implemented as transform.Translate(Vector3.forward, Space.Self);

public void Translate(float x, float y, float z, Transform relativeTo); 
// implemented as transform.Translate(0, 0, 1, Space.Self);


Image of gameplay from the “Driving Simulation” prototype made in Create with Code Unit 1. It shows a red vehicle driving down the middle of a road.

The productivity unit needs to check and see if it’s currently working on a resource pile and then, if it is, perform what occurs in the base GoTo method and return that resource pile’s production output back to its original value before moving away. Let’s override the GoTo methods to do just that.

1. In the ProductivityUnit script, create a new method called ResetProductivity. Both of the GoTo methods require the same functionality, so we’ll build one method to call from both.

2. Next, check to see if the m_CurrentPile variable is null. If it isn’t, then divide the m_currentPile.ProductionSpeed by the ProductivityMultiplier to return it to its original value, and then set it to null. 

void ResetProductivity()
{
    if (m_CurrentPile != null)
    {
        m_CurrentPile.ProductionSpeed /= ProductivityMultiplier;
        m_CurrentPile = null;
    }
}

3. Create a new public override GoTo method with a Building as the target parameter:  

public override void GoTo(Building target)
{

}

4. Call the ResetProductivity method you created and the base.GoTo method.

public override void GoTo(Building target)
{
    ResetProductivity(); // call your new method
    base.GoTo(target); // run method from base class
}

The base label tells the script to run the original method in addition to the new code in this override method. 


5. We’ll repeat the same exact process for the other GoTo: 

public override void GoTo(Vector3 position)
{
    ResetProductivity();
    base.GoTo(position);
}

These methods will run as soon as the user selects a new location for the productivity unit. Before moving, it will return the production speed of the current pile back to its original rate, if a productivity pile was currently selected.

6. Save script and return to Unity, and playtest again. 

7. Send your worker to a resource pile, and select the pile before the worker reaches it.

8. Observe the increased production rate of the resource pile, and then send your worker to another pile.

9. Reselect the original pile, and note that its rate has returned to its reduced amount. 

Inheritance and polymorphism help you create interrelationships between your classes that ultimately help to reduce the total amount of code you need to write. In this tutorial, you created a new class of your own that extended the functionality of the parent Unit class. 

Inheritance and polymorphism in object-oriented programming

1. Overview

2. What is inheritance?

3. What is polymorphism?

4. Create a new unit type

5. Override the BuildingInRange method

6. Understand Overloads

7. Override the GoTo methods

8. Summary

Complete this tutorial