Tracce
/
C#
C#
/
Programma
/
Ereditarietà
Er

Ereditarietà in C#

3 esercizi

Informazioni su Ereditarietà

In C#, una gerarchia di classi può essere definita usando l'ereditarietà, che permette a una classe derivata (Car) di ereditare il comportamento e i dati della sua classe padre (Vehicle). Se non viene specificato alcun genitore, la classe eredita dalla classe object.

Le classi padre possono fornire funzionalità alle classi derivate in tre modi:

  • Definire un metodo normale.
  • Definire un metodo virtual, che è come un metodo normale ma che le classi derivate possono modificare.
  • Definire un metodo abstract, cioè un metodo senza implementazione che le classi derivate devono implementare. Una classe con metodi abstract deve essere contrassegnata a sua volta come abstract. Le classi astratte non possono essere istanziate.

Il modificatore di accesso protected permette di accedere a un membro della classe padre all'interno di una classe derivata, ma blocca l'accesso dalle altre classi. Le classi derivate possono quindi accedere ai membri public e protected della classe padre, ma non ai membri private.

Le classi derivate possono accedere ai membri della classe padre tramite la parola chiave base.

// Inherits from the 'object' class
abstract class Vehicle
{
    // Can be overridden
    public virtual void Drive()
    {
    }

    // Must be overridden
    protected abstract int Speed();
}

// Cannot be inherited from
sealed class Car : Vehicle
{
    public override void Drive()
    {
        // Override virtual method

        // Call parent implementation
        base.Drive();
    }

    protected override int Speed()
    {
        // Implement abstract method
    }
}

Il costruttore di una classe derivata chiamerà automaticamente il costruttore della classe padre prima di eseguire la logica del proprio costruttore. Gli argomenti possono essere passati al costruttore di una classe padre usando la parola chiave base. Dato che le classi astratte non possono essere istanziate, i loro costruttori possono essere resi protected.

abstract class Vehicle
{
    protected Vehicle(int wheels)
    {
        Console.WriteLine("Called first");
    }
}

class Car : Vehicle
{
    public Car() : base(4)
    {
        Console.WriteLine("Called second");
    }
}

Quando più di una classe deriva da una classe base, le due (o più) sottoclassi implementano spesso versioni diverse di un metodo della classe base. Questo è un principio molto importante chiamato polimorfismo. Ad esempio, in una variante dell'esempio precedente mostriamo come il codice che usa Vehicle possa cambiare comportamento a seconda del tipo di veicolo istanziato.

abstract class Vehicle
{
   public abstract string GetDescription();
}

class Car : Vehicle
{
   public Car()
   {
   }

   public override string GetDescription()
   {
      return "Runabout";
   }
}

class Rig : Vehicle
{
   public Rig()
   {
   }

   public override string GetDescription()
   {
      return "Big Rig";
   }
}

Vehicle v1 = new Car();
Vehicle v2 = new Rig();

v1.GetDescription();
// => Runabout
v2.GetDescription();
// => Big Rig

Per impedire che una classe venga ereditata, aggiungi il modificatore sealed. Alcuni sviluppatori cercano di evitare di ereditare da classi concrete (come discusso in questa domanda su SO) e il modificatore sealed supporta questo approccio. D'altra parte, molti sviluppatori C# li considerano un ostacolo alla manutenzione, come discusso in alcuni dei commenti a questa domanda. Il consiglio è di usare il modificatore sealed con moderazione, finché non avrai acquisito sicurezza nel loro uso per le tue esigenze.

Il seguente articolo descrive new come alternativa al modificatore override. A volte è utile, magari con gerarchie di classi complicate e/o una qualche forma di conflitto tra librerie.

Modifica tramite GitHub Il collegamento si apre in una nuova finestra o scheda

Impara Ereditarietà

La pratica è bloccata

Sblocca un altro esercizio per esercitarti su Ereditarietà