Ereditarietà

In assoluto, uno degli aspetti chiave della programmazione orientata agli oggetti (OOP), che è il concetto su cui è costruito C#, è l'ereditarietà, la capacità di creare classi che ereditano certi aspetti dalle classi genitore. l'intero .NET framework è costruito su questo concetto, con "tutto è un oggetto" come risultato. Anche un semplice numero è istanza di una classe, che eredita dalla classe System.Object, sebbene .NET ti aiuti un po' in modo che tu possa assegnare direttamente un numero, invece di dover creare una nuova istanza, ad esempio, della classe integer.

questo tema può essere un po' difficile da comprendere, ma qualche volta può aiutare usare degli esempi, quindi iniziamo con uno di questi:

public class Animal
{
    public void Greet()
    {
        Console.WriteLine("Hello, I'm some sort of animal!");
    }
}

public class Dog : Animal
{

}

Per prima cosa, definiamo una classe Animal, con un semplice metodo per mandare in output un saluto. Poi definiamo una classe Dog e, con il carattere "due punti", diciamo a C# che la classe Dog deve ereditare dalla classe Animal. La cosa bella di questo è che ha senso anche nel mondo reale - un cane è, ovviamente, un animale. Proviamo ad usare le classi:

Animal animal = new Animal();
animal.Greet();
Dog dog = new Dog();
dog.Greet();

Se esegui questo esempio, noterai che anche se non abbiamo definito il metodo Greet() per la classe Dog, saprà ancora come salutarci, perché eredita questo metodo dalla classe Animal. Comunque, questo saluto è un po' anonimo, quindi personalizziamolo quando sappiamo di che animale si tratta:

public class Animal
{
    public virtual void Greet()
    {
        Console.WriteLine("Hello, I'm some sort of animal!");
    }
}

public class Dog : Animal
{
    public override void Greet()
    {
        Console.WriteLine("Hello, I'm a dog!");
    }
}

Oltre al metodo aggiunto, dovresti notare due cose: ho aggiunto la parola chiave "virtual" al metodo nella classe Animal, e nella classe Dog ho usato la parola chiave "override".

In C#, non è consentito fare l'override di un membro di una classe senza marcarlo come "virtual". Se vuoi, puoi ancora accedere al metodo ereditato, anche quando ne fai l'override, usando la parola chiave "base".

public override void Greet()
{
    base.Greet();
    Console.WriteLine("Yes I am - a dog!");
}

Ad ogni modo, i metodi non sono le uniche cose che vengono ereditate. Difatti quasi tutti i membri della classe vengono ereditati, inclusi i campi e le proprietà. Devi solo ricordare le regole di visibilità, come abbiamo detto in un capitolo precedente.

L'ereditarietà non è solo da una classe ad un'altra - puoi avere un'intera gerarchia di classi, che ereditano l'una dall'altra. Ad esempio, potremmo creare una classe Puppy, che eredita dalla classe Dog, che a sua volta eredita dalla classe Animal. Ciò che non puoi fare in C#, è far ereditare contemporaneamente più classi ad una singola classe. L'ereditarietà multipla, come è chiamata, non è supportata da C#.