Ereditarietà: riutilizzare il codice

Benvenuto nella prossima lezione! In questa lezione imparerà a conoscere l'ereditarietà, uno dei principi fondamentali della programmazione orientata agli oggetti, e come consenta di riutilizzare il codice e creare gerarchie. Iniziamo!

Che cos'è l'ereditarietà?

L'ereditarietà consente a una classe (la classe figlia o classe derivata) di acquisire gli attributi e i metodi di un'altra classe (la classe genitore o classe base). Consente di riutilizzare il codice e creare relazioni gerarchiche tra le classi.

Esempio: una classe "Car" potrebbe fungere da classe base per le classi "ElectricCar" e "SportsCar", condividendo proprietà comuni come "Color" e "Speed."

Definizione di una classe base

Una classe base contiene proprietà e metodi comuni che possono essere ereditati dalle classi derivate. Ecco un esempio:

Punto chiave: definisca il codice riutilizzabile nella classe base.

using System;

class Vehicle {
    public string Color;

    public void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

Creazione di una classe derivata

Una classe derivata eredita le proprietà e i metodi di una classe base. Utilizzi il simbolo : per indicare l'ereditarietà. Ecco un esempio:

Punto chiave: le classi derivate possono aggiungere nuove funzionalità o eseguire l'override delle funzionalità della classe base.

using System;

class Vehicle {
    public string Color;

    public void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

class Car : Vehicle {
    public int NumberOfDoors;

    public void ShowDetails() {
        Console.WriteLine("Color: " + Color);
        Console.WriteLine("Doors: " + NumberOfDoors);
    }
}

class Program {
    static void Main() {
        Car myCar = new Car();
        myCar.Color = "Red"; // Inherited from Vehicle
        myCar.NumberOfDoors = 4;
        myCar.Drive(); // Inherited from Vehicle
        myCar.ShowDetails();
    }
}

Override dei metodi

Le classi derivate possono eseguire l'override dei metodi della classe base per fornire un comportamento specializzato. Utilizzi la parola chiave virtual nella classe base e la parola chiave override nella classe derivata. Ecco un esempio:

Suggerimento: l'override è utile per personalizzare il comportamento nelle classi derivate.

using System;

class Vehicle {
    public virtual void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

class SportsCar : Vehicle {
    public override void Drive() {
        Console.WriteLine("The sports car is driving fast!");
    }
}

class Program {
    static void Main() {
        SportsCar myCar = new SportsCar();
        myCar.Drive(); // Calls the overridden method
    }
}

Parola chiave base

La parola chiave base consente di accedere ai membri della classe base dall'interno di una classe derivata. Ecco un esempio:

Suggerimento: Utilizzi base per estendere o integrare il comportamento della classe base.

using System;

class Vehicle {
    public string Color;

    public virtual void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

class Truck : Vehicle {
    public override void Drive() {
        base.Drive(); // Calls the base class method
        Console.WriteLine("The truck is carrying a heavy load.");
    }
}

class Program {
    static void Main() {
        Truck myTruck = new Truck();
        myTruck.Color = "Blue";
        myTruck.Drive();
    }
}

Esercizio pratico

Crei una classe base chiamata Animal con un metodo Speak() che visualizzi «L'animale emette un suono». Crei le classi derivate Dog e Cat che eseguano l'override di Speak() per visualizzare rispettivamente «Il cane abbaia» e «Il gatto miagola». Ecco un esempio:

using System;

class Animal {
    public virtual void Speak() {
        Console.WriteLine("The animal makes a sound.");
    }
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Cat : Animal {
    public override void Speak() {
        Console.WriteLine("The cat meows.");
    }
}

class Program {
    static void Main() {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.Speak();
        myCat.Speak();
    }
}

Buone pratiche per l'ereditarietà

Ecco alcune buone pratiche:

• Utilizzi l'ereditarietà solo quando esiste una chiara relazione di tipo «is-a» (ad esempio, Car è un Vehicle).
• Mantenga le classi base il più possibile generiche.
• Utilizzi sealed per impedire ulteriori ereditarietà quando necessario.

Suggerimento: L'ereditarietà dovrebbe semplificare il codice, non complicarlo.

Ottimo lavoro!

Congratulazioni! Ha imparato a utilizzare l'ereditarietà per riutilizzare il codice e creare gerarchie di classi in C#. Nella prossima lezione approfondiremo il polimorfismo, un altro potente concetto della programmazione orientata agli oggetti. Continui a scrivere codice!