Creating Properties

Ternary Operator

Statics

Method Overloading 

Generics

Inheritance

Polymorphism

Member Hiding

Overriding

Interfaces

Extension Methods 

Namespaces

Lists and Dictionaries 

Coroutines

Quaternions

Delegates

Attributes

Events

How to create properties to access the member variables (fields) in a class.

Properties

How to utilize the Ternary Operator to build simple, shorthand IF-ELSE logical conditions. 

Overview

Before you begin

Syntax

Summary

How to create and use generic methods and classes. 

Polymorphism and casting

 How to create interfaces and implement them in classes. 

What is an interface?

Declare an interface

Implement an interface

Use an implemented interface

The SerializeReference attribute

How to create coroutines and use them to achieve complex behaviours. 

How do coroutines work?

Why do people use coroutines?

Coroutine Syntax

When should you use coroutines?

How to utilize the quaternion system to manage the rotation of game objects. 

 How to create and use delegates to provide complex and dynamic functionality in your scripts. 

Attributes allow you to attach additional behavior to the methods and variables you create. In this video you will learn the format of attributes as well as how to use the "Range" and "ExecuteInEditMode" attributes. 

Attribute syntax

The Range attribute

The CustomEditor attribute

The InitializeOnLoadMethod attribute

This collection of tutorials is an excellent reference point for teachers or students who want to review the higher-level conceptual concepts for developing with Unity. The tutorials included here are intended for people who already have experience with basic scripting and want to understand at a more conceptual level what they’re doing and what is possible with scripting. These skills and concepts are fundamental for anyone who is considering entering the field of computer science.

Before reviewing the tutorials here, it is recommended that you understand all of the concepts covered in “Beginner Scripting” and have completed at least one or two more complex projects or creator kids, such as:

This project contains essential knowledge for intermediate level scripting with these video tutorials. 

2019.3

2019.2

2019.1

2018.4

2018.3

2018.2

2018.1

2017.4

2017.3

2017.2

2017.1

Intermediate Scripting

9ee45c6a-09bd-555d-9d4c-38959d588eb4:6udFvAlfFjsjj7eis1Zqf3

Understand high-level programming concepts (such as inheritance, encapsulation, data abstraction, and polymorphism) and how they are implemented. 

Level 2 Programming theory

Joy Horvath

Instructional Designer

U_Intermediate_7_Polymorphism.mp4

How to use Polymorphism, Upcasting, and Downcasting to create powerful and dynamic functionality between inherited classes. 

Games

Explain how abstraction is used to expose only necessary script components

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 can be applied at compile time (method overloads) and run time (method overrides)

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

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

Recommend a high-level system architecture for a given project 

Simplify code and make it reusable by correctly implementing the principles of inheritance and polymorphism

using UnityEngine;
using System.Collections;

public class Fruit 
{
    public Fruit()
    {
        Debug.Log("1st Fruit Constructor Called");
    }

    public void Chop()
    {
        Debug.Log("The fruit has been chopped.");        
    }

    public void SayHello()
    {
        Debug.Log("Hello, I am a fruit.");
    }
}

using UnityEngine;
using System.Collections;

public class Apple : Fruit 
{
    public Apple()
    {
        Debug.Log("1st Apple Constructor Called");
    }

    //Apple has its own version of Chop() and SayHello(). 
    //When running the scripts, notice when Fruit's version
    //of these methods are called and when Apple's version
    //of these methods are called.
    //In this example, the "new" keyword is used to supress
    //warnings from Unity while not overriding the methods
    //in the Apple class.
    public new void Chop()
    {
        Debug.Log("The apple has been chopped.");        
    }

    public new void SayHello()
    {
        Debug.Log("Hello, I am an apple.");
    }
}

using UnityEngine;
using System.Collections;

public class FruitSalad : MonoBehaviour
{
    void Start () 
    {
        //Notice here how the variable "myFruit" is of type
        //Fruit but is being assigned a reference to an Apple. This
        //works because of Polymorphism. Since an Apple is a Fruit,
        //this works just fine. While the Apple reference is stored
        //in a Fruit variable, it can only be used like a Fruit
        Fruit myFruit = new Apple();

        myFruit.SayHello();
        myFruit.Chop();

        //This is called downcasting. The variable "myFruit" which is 
        //of type Fruit, actually contains a reference to an Apple. Therefore,
        //it can safely be turned back into an Apple variable. This allows
        //it to be used like an Apple, where before it could only be used
        //like a Fruit.
        Apple myApple = (Apple)myFruit;

        myApple.SayHello();
        myApple.Chop();    
    }
}



Polymorphism

1. Polymorphism

Complete this tutorial