Come funzionano l'ereditarietà e il polimorfismo?

Question

Accepted Answer

**Ereditarietà** consente a una classe di derivare da una classe base, riutilizzando ed estendendo i suoi membri. **Polimorfismo** consente di trattare oggetti derivati attraverso un tipo base, con il metodo sovrascritto corretto chiamato a runtime (tramite `virtual`/`override`). Questi sono meccanismi fondamentali della OOP in C#.

## Ereditarietà

```csharp
public class Animal
{
    public string Name { get; set; }
    public virtual string MakeSound() => "some sound";   // virtual — can be overridden
}

public class Dog : Animal     // Dog inherits from Animal (single inheritance)
{
    public override string MakeSound() => "Woof";        // OVERRIDE the base method
    public void Fetch() => Console.WriteLine("fetching");
}

var dog = new Dog { Name = "Rex" };
dog.Name;          // inherited from Animal
dog.MakeSound();    // "Woof"
```

Una classe derivata (`Dog : Animal`) eredita i membri della base e può aggiungerne di propri. C# supporta **ereditarietà singola** (una sola classe base). `base.Method()` chiama l'implementazione della base.

## Polimorfismo — virtual / override

```csharp
// treat different derived types through the base type; the ACTUAL type's method runs
List<Animal> animals = new() { new Dog(), new Cat() };
foreach (Animal a in animals)
    Console.WriteLine(a.MakeSound());   // "Woof", "Meow" — runtime dispatch
```

**Polimorfismo**: un metodo `virtual` sovrascritto in classi derivate viene inviato a **runtime** in base al tipo effettivo dell'oggetto — quindi la stessa chiamata (`a.MakeSound()`) fa cose diverse per ogni tipo. Questo consente codice flessibile ed estensibile (gestire molti tipi uniformemente).

## Classi astratte e sealed

```csharp
public abstract class Shape
{
    public abstract double Area();        // abstract — derived MUST implement, no body
    public string Describe() => $"Area: {Area()}";   // concrete shared method
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
// var s = new Shape();   // ❌ can't instantiate an abstract class

public sealed class Final { }   // sealed — cannot be inherited from
```

**Classi astratte** definiscono una base parziale (con metodi astratti che le sottoclassi devono implementare più codice condiviso); `sealed` previene ulteriore ereditarietà.

## Perché è importante

L'ereditarietà e il polimorfismo sono meccanismi fondamentali della OOP in C#, essenziali per il design orientato agli oggetti e per lavorare con il framework .NET (che li utilizza estensivamente), quindi comprenderli è fondamentale. **L'ereditarietà** fornisce riuso del codice tramite relazioni "è-un" (un Dog è un Animal), sebbene C# consenta solo ereditarietà singola. **Il polimorfismo** — tramite `virtual`/`override` e invio di metodi a runtime — è particolarmente importante: consente di trattare diversi tipi derivati uniformemente attraverso un tipo base mentre il comportamento specifico del tipo corretto viene eseguito automaticamente, abilitando design flessibili ed estensibili (elaborare una raccolta di forme diverse, ciascuna calcolando la propria area).

Comprendere il meccanismo `virtual`/`override` (la base contrassegna un metodo come sovrascritto, le classi derivate lo sovrascriv, e il runtime invia alla versione del tipo effettivo), le **classi astratte** (basi parziali con metodi che le sottoclassi devono implementare più codice condiviso) e `sealed` (prevenendo l'ereditarietà) è necessario per progettare gerarchie di classi e per comprendere come il framework .NET e le librerie sono strutturate.

Poiché l'ereditarietà e il polimorfismo sono alla base di C# orientato agli oggetti e del framework stesso, e poiché il polimorfismo runtime è un fattore abilitante chiave di codice estensibile e manutenibile, padroneggiare questi — specialmente l'invio virtual/override che rende il polimorfismo funzionante — è conoscenza importante e frequentemente applicata per il design orientato agli oggetti in C#, e un argomento comune nei colloqui che rivela la comprensione dei fondamenti della OOP.