Wie funktionieren Vererbung und Polymorphismus?

Question

Accepted Answer

**Vererbung** ermöglicht es einer Klasse, von einer Basisklasse abzuleiten, deren Member wiederzuverwenden und zu erweitern. **Polymorphismus** ermöglicht es, abgeleitete Objekte über einen Basistyp zu behandeln, wobei die korrekte überschriebene Methode zur Laufzeit aufgerufen wird (über `virtual`/`override`). Dies sind grundlegende OOP-Mechanismen in C#.

## Vererbung

```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"
```

Eine abgeleitete Klasse (`Dog : Animal`) erbt die Member der Basisklasse und kann eigene hinzufügen. C# unterstützt **Einfachvererbung** (eine Basisklasse). `base.Method()` ruft die Basisimplementierung auf.

## Polymorphismus — 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
```

**Polymorphismus**: Eine `virtual`-Methode, die in abgeleiteten Klassen überschrieben ist, wird zur **Laufzeit** basierend auf dem tatsächlichen Typ des Objekts aufgerufen — so führt derselbe Aufruf (`a.MakeSound()`) je nach Typ unterschiedliche Aktionen aus. Dies ermöglicht flexiblen, erweiterbaren Code (viele Typen einheitlich behandeln).

## Abstrakte Klassen und 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
```

**Abstrakte Klassen** definieren eine partielle Basis (mit abstrakten Methoden, die Unterklassen implementieren müssen, plus gemeinsamen Code); `sealed` verhindert weitere Vererbung.

## Warum es wichtig ist

Vererbung und Polymorphismus sind grundlegende OOP-Mechanismen in C#, fundamental für objektorientierten Entwurf und für die Arbeit mit dem .NET-Framework (das sie umfangreich nutzt), daher ist das Verständnis dafür essentiell. **Vererbung** ermöglicht Codewiederverwertung durch "ist-ein"-Beziehungen (ein Dog ist ein Animal), wobei C# nur Einfachvererbung erlaubt. **Polymorphismus** — durch `virtual`/`override` und Laufzeit-Methodenauflösung — ist besonders wichtig: Er ermöglicht es, verschiedene abgeleitete Typen einheitlich über einen Basistyp zu behandeln, während das korrekte typspezifische Verhalten automatisch ausgeführt wird, was flexible, erweiterbare Entwürfe ermöglicht (eine Kollektion verschiedener Formen verarbeiten, jede berechnet ihre eigene Fläche).

Das Verständnis des `virtual`/`override`-Mechanismus (die Basis markiert eine Methode als überschreibbar, abgeleitete Klassen überschreiben sie, und die Laufzeit leitet an die Version des tatsächlichen Typs weiter), **abstrakte Klassen** (partielle Basen mit Methoden, die Unterklassen implementieren müssen, plus gemeinsamer Code) und `sealed` (verhindert Vererbung) ist notwendig, um Klassenhierarchien zu entwerfen und um zu verstehen, wie das .NET-Framework und Bibliotheken strukturiert sind.

Da Vererbung und Polymorphismus objektorientierten C# und dem Framework selbst zugrunde liegen, und da Laufzeit-Polymorphismus ein Schlüsselfaktor für erweiterbaren, wartbaren Code ist, ist das Beherrschen dieser — besonders der virtual/override-Auflösung, die Polymorphismus ermöglicht — wichtiges, häufig angewendetes Wissen für objektorientierten Entwurf in C# und ein häufiges Interviewthema, das das Verständnis von OOP-Grundlagen offenbart.