1️⃣ Definizione di ereditarietà

In C#, si dice che una classe A è una sottoclasse di B (o che B è una superclasse di A) quando:

• A eredita da B sia il suo stato che il suo comportamento (metodi).

• Un'istanza della classe A può essere usata ovunque si possa utilizzare un'istanza della classe B.

Per esempio:

classDiagram
    Persona --|> Studente : Ereditarietà

    note for Persona "classe base"
    note for Studente "classe derivata"

📖 Un oggetto della classe Studente appartiene alla classe degli studenti e anche alla classe delle persone (ma non viceversa).

→ Un oggetto Studente ha tutte le proprietà (attributi e metodi) della classe Persona e può aggiungere ulteriori proprietà specifiche.

namespace Ereditarieta
{
    // Classe base
    public class Persona
    {
        // Attributi della classe
        private string nome;
        private string cognome;
        private string dataNascita;

        // Costruttore
        // ...

        // Metodi della classe
        // ...
    }

    // La classe Studente eredita da Persona
    // => ha accesso agli attributi e ai metodi protetti e pubblici.
    public class Studente : Persona
    {
        // Attributi della classe
        private string matricola;

        // Costruttore
        // ...

        // Metodi della classe
        // ...
    }
}

2️⃣ Visibilità

Visibilità dei campi (dati/record) in una classe C#:

3️⃣ Classe Object

In C#, tutte le classi ereditano dalla classe base Object, che è inclusa nel namespace System.

graph BT
  Rettangolo --> Object
  Quadrato --> Rettangolo

La classe Object contiene l'implementazione predefinita di alcuni metodi fondamentali, tra cui:

• Equals(Object obj) → boolean
  • Confronta i riferimenti di due oggetti (simile a ==).

• ToString() → string
  • Restituisce una stringa che rappresenta l'oggetto.

• GetHashCode() → int
  • Restituisce un codice hash per l'oggetto.

Questi metodi possono essere ridefiniti in qualsiasi classe derivata.

4️⃣ Operatore is

In C#, è possibile determinare se un oggetto o appartiene o no a una classe c con l'operatore is:

if (o is c)
{
    // L'oggetto o è di tipo c
}

Restituisce:

• true se l'oggetto o è di tipo c.

• false altrimenti.

5️⃣ Esempio Completo

classDiagram
    Rettangolo --|> Quadrato : Ereditarietà
    class Rettangolo {
        - base: int
        - altezza: int
        + Rettangolo()
        + Rettangolo(int, int)
        + Perimetro() int
        + Area() int
        + GetAltezza() int
        + GetBase() int
    }
    class Quadrato {
        + Quadrato()
        + Quadrato(int)
        + Circonferenza() double
        + Perimetro() int
    }

namespace EreditarietaEsempioCompleto
{
    // Classe base
    public class Rettangolo
    {
        // Attributi
        private int baseRettangolo;
        private int altezza;

        // Costruttore senza parametri
        public Rettangolo()
        {
            baseRettangolo = 0;
            altezza = 0;
        }

        // Costruttore con parametri
        public Rettangolo(int baseRettangolo, int altezza)
        {
            this.baseRettangolo = baseRettangolo;
            this.altezza = altezza;
        }

        // Metodo per calcolare il perimetro
        public int Perimetro()
        {
            return 2 * baseRettangolo + 2 * altezza;
        }

        // Metodo per calcolare l'area
        public int Area()
        {
            return baseRettangolo * altezza;
        }

        // Metodi getter
        public int GetBase()
        {
            return baseRettangolo;
        }

        public int GetAltezza()
        {
            return altezza;
        }
    }

    // Classe derivata
    public class Quadrato : Rettangolo
    {
        // Costruttore senza parametri
        public Quadrato() : base() {}

        // Costruttore con un parametro
        public Quadrato(int lato) : base(lato, lato) {}

        // Metodo per calcolare la circonferenza
        public double Circonferenza()
        {
            return GetAltezza() * 3.14;
        }

        // Metodo per calcolare il perimetro
        public new int Perimetro()
        {
            return base.Perimetro();
        }
    }

    public class MainProgram
    {
        public static void Main(string[] args)
        {
            Rettangolo r1 = new Rettangolo(5, 7);
            Quadrato q1 = new Quadrato(4);

            Console.WriteLine(r1.Area());  // area del rettangolo
            Console.WriteLine(q1.Area());  // area del quadrato

            Console.WriteLine(r1 is Rettangolo); // -> true
            Console.WriteLine(q1 is Quadrato); // -> true
            Console.WriteLine(q1 is Rettangolo); // -> true
            Console.WriteLine(r1 is Quadrato); // -> false
            Console.WriteLine(q1 is Object); // -> true
        }
    }
}

📑 Esercizi

1. Crea una classe Animale con proprietà come Specie e Verso. Definisci una classe Cane che eredita da Animale e aggiunge una proprietà Razza.

2. Scrivi un programma che usa l’operatore is per verificare se un oggetto di tipo Animale è di tipo Cane.

3. Estendi la classe Rettangolo per creare una classe Parallelepipedo che aggiunge l’attributo Altezza.