MonoBehavior - Base-Class

MonoBehaviour

MonoBehaviour is a C# class that is part of the Unity Engine. Almost all of the C# classes that we create will inherit from the MonoBehavior class. This inheritance relationship means that our script component objects can be attached to Unity GameObjects and their Start() and Update() methods will be executed when our gameObject is part of the currently active Unity Scene. In order for a script to be attached to a gameObject, it must inherit from the MonoBehaviour class. A custom script that has MonoBehaviour as the base class can be added as a ( Monobehaviour ) component to a GameObject

C# Inheritance

The Syntax for indicating that a class inherits from a base class in C# is shown below, the colon : is used to inheritance from a base class, MonoBehaviour is the base-class for all Unity MonoBehaviour Components. The code below shows that every script that defines a custom component is a C# class definition.

public class Example: MonoBehaviour // colon indicates MonoBehaviour is the base class 

Access Modifiers to Support Encapsulation

For C#, we must specify access modifiers for each class, class variable and class method. We will work with public, and private modifiers. If no modifier is specified, the modifier is private by default. A class variable with public as the modifier will be visible and editable in the inspector. Anything defined with private access modifier can not be accessed outside the class, this helps protect the integrity of the class because nothing can be accidentally modified outside the class. Encapsulation refers to this protection of class integrity. For variables that we'd like to provide read access to, we can define a special type of variable called a property that gives more granular access to a private class variable. Any method that will be accessed outside the class where it is defined must have that access modifier defined as public. There is also a protected modifier that provides access to base-class elements from within child classes, but acts as private modifier when trying to access the element from any other class..

using UnityEngine;
using System.Collections;
using UnityEngine.UI;   //Add if this script will use UI elements

public class Example: MonoBehaviour {

  public Text myText;   //define a variable that can be modified in the inspector
  //Use this for initialization
  void Start () { //this code is executed one time
    Debug.Log("Initialization has occured");
  }
  //Update is called once per frame
  void Update () { //this code is executed once each frame
    Debug.Log("Update Called");
  }
}

C# Interfaces

C# Interfaces are similar to Class Inheritance in C#. C# Interfaces can be implemented to provide similar behavior across different C# classes. We'll discuss interfaces later in the course. For now it's important to note that in C#, a class can only inherit from a single base class, but a class can implement multiple interfaces. Unity's Component-Oriented architecture benefits from using Interfaces for reasons listed in the article quoted below.

"Interfaced-based design provides loose coupling, true component-based programming, easier maintainability and it makes code reuse much more accessible because implementation is separated from the interface." Matthew Cochran

public class myClass : BaseClass, ISomeInterface, ISomeOtherInterface{  //single level of inheritance, unlimited interface implementation, a comma separated list.

}