Overerving stelt een klasse in staat om af te leiden van een basisklasse en de leden ervan opnieuw te gebruiken en uit te breiden. Polymorfisme stelt je in staat om afgeleide objecten te behandelen via een basistype, waarbij de juiste overschreven methode tijdens runtime wordt aangeroepen (via virtual/override). Dit zijn kernmechanismen van 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"
Een afgeleide klasse (Dog : Animal) erft de leden van de basis en kan zijn eigen leden toevoegen. C# ondersteunt enkele overerving (één basisklasse). base.Method() roept de basisimplementatie aan.
// 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
Polymorfisme: een virtual methode die in afgeleide klassen is overschreven, wordt tijdens runtime afgestemd op het werkelijke type van het object — dus dezelfde aanroep (a.MakeSound()) doet verschillende dingen per type. Dit maakt flexibele, uitbreidbare code mogelijk (behandel veel typen uniform).
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
Abstracte klassen definiëren een gedeeltelijke basis (met abstracte methoden die subklassen moeten implementeren, plus gedeelde code); sealed voorkomt verdere overerving.
Overerving en polymorfisme zijn kernmechanismen van OOP in C#, fundamenteel voor object-georiënteerd ontwerp en voor het werken met het .NET-framework (dat ze uitgebreid gebruikt), dus het begrijpen ervan is essentieel. Overerving biedt hergebruik van code via "is-a"-relaties (een Dog is een Animal), hoewel C# alleen enkele overerving toestaat. Polymorfisme — via virtual/override en runtime-methodeafzending — is bijzonder belangrijk: het stelt je in staat verschillende afgeleide typen uniform te behandelen via een basistype, terwijl het juiste typespecifieke gedrag automatisch wordt uitgevoerd, wat flexibele, uitbreidbare ontwerpen mogelijk maakt (verwerk een verzameling van verschillende vormen, elk berekent zijn eigen oppervlakte).
Het begrijpen van het virtual/override-mechanisme (de basis markeert een methode als overschrijfbaar, afgeleide klassen schrijven het over, en de runtime zend uit naar de versie van het werkelijke type), abstracte klassen (gedeeltelijke bases met methoden die subklassen moeten implementeren plus gedeelde code), en sealed (overerving voorkomen) is noodzakelijk voor het ontwerpen van klassehiërarchieën en voor het begrijpen hoe het .NET-framework en bibliotheken zijn opgebouwd.
Aangezien overerving en polymorfisme ten grondslag liggen aan object-georiënteerde C# en het framework zelf, en aangezien runtime-polymorfisme een sleutelfactor is voor uitbreidbare, onderhoudbare code, is het beheersen hiervan — vooral de virtual/override-afzending die polymorfisme laat werken — belangrijk, frequent toegepaste kennis voor object-georiënteerd ontwerp in C# en een veelvoorkomend interviewonderwerp dat het begrip van OOP-fundamenten onthult.