Zauberer und Krieger

Vererbung

In C# kannst du eine Klassen-Hierarchie mithilfe von Vererbung definieren. Eine abgeleitete Klasse (Car) erbt dabei das Verhalten und die Daten ihrer Elternklasse (Vehicle). Wenn keine Elternklasse angegeben ist, erbt die Klasse von der object-Klasse.

Elternklassen können abgeleiteten Klassen auf drei Arten Funktionalität bereitstellen:

• Definiere eine normale Methode.
• Definiere eine virtual-Methode. Sie ist wie eine normale Methode, aber abgeleitete Klassen können sie ändern.
• Definiere eine abstract-Methode. Das ist eine Methode ohne Implementierung, die abgeleitete Klassen implementieren müssen. Eine Klasse mit abstract-Methoden muss ebenfalls als abstract gekennzeichnet sein. Abstrakte Klassen kannst du nicht instanziieren.

Mit dem Zugriffsmodifikator protected kannst du in einer abgeleiteten Klasse auf ein Mitglied der Elternklasse zugreifen. Von anderen Klassen aus ist dieser Zugriff aber blockiert.

Abgeleitete Klassen können über das Schlüsselwort base auf Mitglieder der Elternklasse zugreifen.

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

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

class Car : Vehicle
{
    public override void Drive()
    {
        // Override virtual method

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

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

Der Konstruktor einer abgeleiteten Klasse ruft automatisch den Konstruktor ihrer Elternklasse auf, bevor er die eigene Logik ausführt. Mit dem Schlüsselwort base kannst du Argumente an den Konstruktor der Elternklasse übergeben:

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

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

Wenn mehr als eine Klasse von einer Basisklasse abgeleitet ist, implementieren diese zwei (oder mehr) Klassen oft unterschiedliche Versionen einer Methode der Basisklasse. Das ist ein sehr wichtiges Prinzip, das man Polymorphismus nennt. An einer Variation des obigen Beispiels zeigen wir, wie Code, der Vehicle verwendet, sein Verhalten ändern kann, je nachdem, welcher Fahrzeugtyp instanziiert wurde.

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