Unity Basics Course: Registering Parent Class

In this lecture, we will understand the concept of parent class registration in Unity and how it is utilized in actual game development. Classes are a crucial concept in object-oriented programming, and the relationship between parent classes and child classes plays a significant role in enhancing code reusability and maintainability.

1. Object-Oriented Programming and Classes

Object-Oriented Programming (OOP) is one of the software development paradigms that encapsulates data into units called objects. A class is a blueprint for creating objects, defining their state (attributes) and behavior (methods).

1.1 Basic Understanding of Classes and Objects

A class is a framework for creating objects. For example, if we define a class called Car, we can create multiple Car objects based on this class:

class Car {
        public string color;
        public string model;

        public void Drive() {
            Debug.Log("The car is driving");
        }
    }
    

In the above class, color and model are attributes, while Drive is a method. This allows us to create multiple Car objects and utilize their attributes and methods.

1.2 Importance of Inheritance

Inheritance is a vital feature that creates relationships between classes. A parent class (base class) can pass its attributes and methods to a child class (derived class). This characteristic helps reduce code duplication and facilitates maintenance.

2. Defining a Parent Class

To define a parent class, we use the class keyword to create a class. Let’s examine this through the example below:

class Animal {
        public string name;

        public void Speak() {
            Debug.Log(name + " says hello!");
        }
    }
    

The above code defines a parent class called Animal. This class has an attribute called name and a method called Speak.

2.1 Creating a Child Class

To create a child class that inherits from a parent class, we use the : symbol. The example below shows a Dog class inheriting from the Animal class:

class Dog : Animal {
        public void Bark() {
            Debug.Log(name + " says woof!");
        }
    }
    

The above code demonstrates that the Dog class inherits attributes and methods from the Animal class.

3. Registering the Parent Class

The process of registering a parent class in Unity is very simple. Create a Scripts folder in the Unity Editor and write a C# script to define the parent class. Then, create a class that inherits from the parent class in the code and connect it to a game object for use.

3.1 Creating the Script

To register the parent class in Unity, create a file named Animal.cs:

using UnityEngine;

    public class Animal {
        public string name;

        public void Speak() {
            Debug.Log(name + " says hello!");
        }
    }
    

3.2 Connecting the Child Class

Create a child class called Dog.cs that inherits from the Animal class:

using UnityEngine;

    public class Dog : Animal {
        public void Bark() {
            Debug.Log(name + " says woof!");
        }
    }
    

3.3 Using the Script

Now, write a new C# script to connect the Dog class to a game object and create an instance using the Dog class:

using UnityEngine;

    public class DogController : MonoBehaviour {
        private Dog myDog;

        void Start() {
            myDog = new Dog();
            myDog.name = "Buddy";
            myDog.Speak();
            myDog.Bark();
        }
    }
    

4. Practicing Parent Class Registration

Now that you have learned how to register a parent class, let’s create a simple project using this knowledge. Follow the steps below for practice:

4.1 Creating a New C# Script

In the Unity Editor, create a new C# script and write the following code:

public class Cat : Animal {
        public void Meow() {
            Debug.Log(name + " says meow!");
        }
    }
    

4.2 Creating Game Objects and Connecting Scripts

Create a game object and connect the DogController script that you wrote above. You can also connect and use the Cat class through this script.

5. Utilizing Inheritance

Inheritance through parent and child classes offers many advantages. It increases code reusability and creates a maintainable structure. Additionally, leveraging inheritance enhances code readability and significantly aids in extending functionality.

5.1 Polymorphism

In game engines like Unity, polymorphism allows you to manage various child classes of a parent class in arrays or collections. This enables efficient handling of objects with diverse behaviors:

public class AnimalManager : MonoBehaviour {
        private Animal[] animals;

        void Start() {
            animals = new Animal[2];
            animals[0] = new Dog { name = "Buddy" };
            animals[1] = new Cat { name = "Kitty" };

            foreach (Animal animal in animals) {
                animal.Speak();
            }
        }
    }
    

6. Conclusion

In this lecture, we learned in detail about the concept and implementation of parent class registration in Unity. We understood that using the inheritance feature of object-oriented programming allows effective utilization of parent class attributes and methods in child classes. This structure enhances code reusability and maintainability, which will greatly assist in managing multiple characters and objects in game development.