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#.
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.
// 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).
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à.
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.
Una raccolta di domande di colloquio IT con risposte dettagliate — da Junior a Senior.
Dona