Unity 3D Game Engine – JavaScript – Inheritance (Ereditarietà)

Unity 3D Game Engine – JavaScript – Inheritance (Ereditarietà)

L’ereditarietà fra le classi serve per creare una relazione forte tra classi con rapporto padre-figlio.
La classe figlio potrà accedere a tutti i costruttori della classe padre.

Le classi potranno essere:
– padre public -> il figlio e anche tutte le altre classi non imparentate potranno accedere ai costruttori di funzione del padre
– padre private -> i costruttori nel padre postranno esistere ma il figlio non vi potrà accedere
– padre protected -> solo il figlio potrà accedere ai costruttori del padre

Un esempio tratto dal mondo dei videogiochi potrebbe essere:

Humanoid class

– Player class

– Enemies class
— Orc class
— Goblins class

Fruit Class

#pragma strict

public class Fruit (Frutta)
{
    public var color: String;
    
    //This is the first constructor for the Fruit class
    //and is not inherited by any derived classes.
    public function Fruit()
    {
        color = "orange";
        Debug.Log("1st Fruit Constructor Called");
    }
    
    //This is the second constructor for the Fruit class
    //and is not inherited by any derived classes.
    public function Fruit(newColor : String)
    {
        color = newColor;
        Debug.Log("2nd Fruit Constructor Called");
    }
    
    public function Chop()
    {
        Debug.Log("The " + color + " fruit has been chopped.");     
    }
    
    public function SayHello()
    {
        Debug.Log("Hello, I am a fruit.");
    }
}

Apple Class (Mele)

#pragma strict

//This is the derived class whis is
//also know as the Child class.
public class Apple extends Fruit 
{
    
    //This is the first constructor for the Apple class.
    //It calls the parent constructor immediately, even
    //before it runs.
    public function Apple()
    {
        //Notice how Apple has access to the public variable
        //color, which is a part of the parent Fruit class.
        color = "red";
        Debug.Log("1st Apple Constructor Called");
    }
    
    //This is the second constructor for the Apple class.
    //It specifies which parent constructor will be called
    //using the "base" keyword.
    public function Apple(newColor : String)
    {
        super(newColor);
    
        //Notice how this constructor doesn't set the color
        //since the base constructor sets the color that
        //is passed as an argument.
        Debug.Log("2nd Apple Constructor Called");
    }
    
}

FruitSalad Class (Insalata di frutta)

#pragma strict
    
function Start () 
{   
    //Let's illustrate inheritance with the 
    //default constructors.
    Debug.Log("Creating the fruit");
    var myFruit = new Fruit();
    Debug.Log("Creating the apple");
    var myApple = new Apple();
        
    //Call the methods of the Fruit class.
    myFruit.SayHello();
    myFruit.Chop();
        
    //Call the methods of the Apple class.
    //Notice how class Apple has access to all
    //of the public methods of class Fruit.
    myApple.SayHello();
    myApple.Chop();
        
    //Now let's illustrate inheritance with the 
    //constructors that read in a string.
    Debug.Log("Creating the fruit");
    myFruit = new Fruit("yellow");
    Debug.Log("Creating the apple");
    myApple = new Apple("green");
        
    //Call the methods of the Fruit class.
    myFruit.SayHello();
    myFruit.Chop();
        
    //Call the methods of the Apple class.
    //Notice how class Apple has access to all
    //of the public methods of class Fruit.
    myApple.SayHello();
    myApple.Chop();
}

Come funziona?

1. Fruit Class
– creo una classe pubblica perchè devo poter accedere ai dati da altre classi esterne
– creo una funzione pubblica Fruit() con all’interno la variabile ‘color’

2. Apple Class
– creo la classe pubblica Apple() figlia di Fruit()

... Apple extends Fruit  ...

– accede alla variabile pubblica ‘color’ della classe Fruit() e gli assegna il valore ‘red’
– ‘red’ viene inviato come una stringa a ‘newColor’ di public function Fruit(newColor : String)

3. FruitSalad Class (macedonia)
Per fare la macedonia dobbiamo mischiare il frutto ‘orange’ di Fruit() e quello ‘red’ di Apple().
– nella funzione Start() che viene eseguita all’avvio del programma richiamo:

– la classe Fruit(). funzione SayHello()
-> “Hello, I am a fruit.”

– la classe Fruit(). funzione Chop()
-> “The ” + orange + ” fruit has been chopped.”

– la classe Apple(). funzione SayHello() della classe padre
-> “Hello, I am a fruit.”

– la classe Apple(). funzione Chop() della classe padre
-> “The” + yellow + ” fruit has been chopped.”

Un’altro sistema consiste nell’inviare dellew stringhe alle classiu padre-figlio come segue:

    //Now let's illustrate inheritance with the 
    //constructors that read in a string.
    Debug.Log("Creating the fruit");
    myFruit = new Fruit("yellow");
    Debug.Log("Creating the apple");
    myApple = new Apple("green");
        
    //Call the methods of the Fruit class.
    myFruit.SayHello();
    myFruit.Chop();