Tracks
/
C#
C#
/
Lehrplan
/
Vererbung
Ve

Vererbung in C#

3 Übungen

Über Vererbung

In C# lässt sich mit Vererbung eine Klassen-Hierarchie definieren, bei der eine abgeleitete Klasse (Car) das Verhalten und die Daten ihrer Basisklasse (Vehicle) erbt. Wird keine Basisklasse angegeben, erbt die Klasse von der Klasse object.

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

  • Eine normale Methode definieren.
  • Eine virtual-Methode definieren, die wie eine normale Methode ist, aber von abgeleiteten Klassen geändert werden kann.
  • Eine abstract-Methode definieren. Das ist eine Methode ohne Implementierung, die abgeleitete Klassen implementieren müssen. Eine Klasse mit abstract-Methoden muss ebenfalls als abstract gekennzeichnet werden. Abstrakte Klassen können nicht instanziiert werden.

Der protected-Zugriffsmodifikator erlaubt den Zugriff auf ein Member der Basisklasse in einer abgeleiteten Klasse, blockiert aber den Zugriff aus anderen Klassen. Abgeleitete Klassen können also auf public- und protected-Member der Basisklasse zugreifen, aber nicht auf private-Member.

Über das base-Schlüsselwort können abgeleitete Klassen auf Member der Basisklasse zugreifen.

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

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

// Cannot be inherited from
sealed 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 Basisklasse auf, bevor er die eigene Logik ausführt. Mit dem base-Schlüsselwort lassen sich Argumente an den Konstruktor der Basisklasse übergeben. Da abstrakte Klassen nicht instanziiert werden können, können ihre Konstruktoren protected sein.

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 wird, implementieren die zwei (oder mehr) Unterklassen oft unterschiedliche Versionen einer Methode der Basisklasse. Das ist ein sehr wichtiges Prinzip namens Polymorphismus. In einer Variante des obigen Beispiels zeigen wir, wie Code mit Vehicle sein Verhalten je nach Typ des instanziierten Fahrzeugs ändern kann.

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

Um zu verhindern, dass eine Klasse vererbt wird, fügst du den sealed-Modifikator hinzu. Manche Entwickler versuchen, das Erben von konkreten Klassen zu vermeiden (wie in dieser SO-Frage diskutiert), und der sealed-Modifikator unterstützt diesen Ansatz. Andererseits halten viele C#-Entwickler ihn für ein Hindernis bei der Wartung, wie in einigen Kommentaren zu dieser Frage diskutiert wird. Der Rat ist, den sealed-Modifikator sparsam einzusetzen, bis du Sicherheit in seiner Verwendung für deine Anforderungen gewonnen hast.

Der folgende Artikel beschreibt new als Alternative zum override-Modifikator. Das ist gelegentlich nützlich, etwa bei verworrenen Klassenhierarchien und/oder irgendeinem Konflikt zwischen Bibliotheken.

Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab

Lerne Vererbung

Das Üben ist gesperrt

Schalte 1 weitere Übung frei, um Vererbung zu üben