C# base virtual override: Vererbung einfach erklärt

Stell dir vor, du entwickelst eine Fahrzeug-Verwaltung in C#. Du hast eine Basisklasse `Fahrzeug` mit einer Methode `StarteMotor()`. Jetzt brauchst du eine Klasse `Elektroauto`, die diese Methode erweitert - der Motor soll starten, aber vorher soll der Akku geprüft werden. Genau hier kommen `base`, `virtual` und `override` ins Spiel.

Ob du dich gerade auf deine IHK-Abschlussprüfung als Fachinformatiker vorbereitest, Objektorientierung an der Hochschule durchnimmst oder dein erstes richtiges Projekt im Job startest - wer C# programmiert, trifft früher als gedacht auf dieses Trio. Die gute Nachricht: Es ist simpler, als es klingt.

In diesem Artikel erklären wir C# base virtual override anhand konkreter Beispiele, sodass du das Konzept direkt anwenden kannst.

Was sind base, virtual und override in C#?

`virtual` markiert eine Methode in einer Basisklasse als überschreibbar. `override` in einer abgeleiteten Klasse ersetzt diese Methode mit einer eigenen Implementierung. `base` greift dabei auf die ursprüngliche Methode der Basisklasse zu.

Stell dir das wie ein Rezeptbuch vor: Die Basisklasse liefert das Grundrezept. Mit `override` schreibst du eine neue Version. Mit `base` greifst du aber trotzdem auf die Original-Zutaten zurück.

Kurz gesagt: `virtual` erlaubt Überschreibung, `override` führt sie aus, `base` holt dir die ursprüngliche Logik.

Wann nutzt man virtual und override?

`virtual` und `override` brauchst du immer dann, wenn eine abgeleitete Klasse das Verhalten einer Methode ändern oder erweitern soll. Ohne `virtual` ist die Methode in C# standardmäßig versiegelt - sie kann nicht überschrieben werden.

Hier ein einfaches Beispiel:

using System;

public class Fahrzeug
{
  public virtual void StarteMotor()
  {
    Console.WriteLine("Motor startet... Brumm brumm!");
  }
}

public class Elektroauto : Fahrzeug
{
  public override void StarteMotor()
  {
    Console.WriteLine("Akku-Check... 100%");
    Console.WriteLine("Elektromotor startet leise...");
  }
}

Die Methode in `Fahrzeug` ist mit `virtual` markiert - sie darf überschrieben werden. In `Elektroauto` nutzt du `override`, um das Verhalten anzupassen. Ein Elektroauto startet eben anders als ein Verbrenner.

Wichtig: `virtual` erlaubt Überschreibung - es zwingt dich aber nicht dazu. Du kannst die Methode auch einfach so verwenden wie sie ist.

Ohne `virtual` könntest du die Methode nicht überschreiben. Warum? Weil C# Methoden standardmäßig als nicht überschreibbar behandelt - sie sind nicht für Vererbung gedacht, außer du erlaubst es explizit. Das ist ein bewusster Unterschied zu Java, wo Methoden automatisch überschreibbar sind. Mehr dazu findest du in der offiziellen C#-Dokumentation zur Vererbung.

Wie nutzt man base richtig?

`base` ist quasi der Anruf bei der Basisklasse: "Hey, mach du erstmal dein Ding - dann mache ich weiter." Du nutzt `base` für zwei Dinge: den Konstruktor der Basisklasse aufrufen (`: base()`) und die überschriebene Methode aufrufen (`base.Methodenname()`).

Hier ein vollständiges Beispiel:

using System;

public class Fahrzeug
{
  protected int baujahr;

  public Fahrzeug(int baujahr)
  {
    this.baujahr = baujahr;
  }

  public virtual void ZeigeInfo()
  {
    Console.WriteLine($"Fahrzeug aus dem Jahr {baujahr}");
  }
}

public class Sportwagen : Fahrzeug
{
  private int leistung;

  // base() ruft den Konstruktor der Basisklasse auf
  public Sportwagen(int baujahr, int leistung) : base(baujahr)
  {
    this.leistung = leistung;
  }

  public override void ZeigeInfo()
  {
    // base.ZeigeInfo() ruft die Original-Methode auf
    base.ZeigeInfo();
    Console.WriteLine($"Leistung: {leistung} PS");
  }
}

public class Program
{
  public static void Main()
  {
    Sportwagen meinWagen = new Sportwagen(2024, 450);
    meinWagen.ZeigeInfo();
  }
}

Ausgabe:

Fahrzeug aus dem Jahr 2024
Leistung: 450 PS

Ohne `base.ZeigeInfo()` würde die Basisklasse ignoriert - du würdest nur die Leistung sehen. Mit `base` greifst du auf die Original-Implementierung zurück und erweiterst sie.

Best Practice: Nutze `base.Methodenname()`, wenn du die Original-Logik erhalten und erweitern willst. Lass `base` weg, wenn du die Methode komplett ersetzen möchtest.

base, virtual, override und new im Vergleich

Die vier Schlüsselwörter lassen sich am besten direkt vergleichen. Den Unterschied zwischen `override` und `new` kennen viele Azubis und Studenten nicht - dabei ist er relevant für die Abschlussprüfung oder Programmieraufgaben im Studium.

• `override`: Die Methode wird ersetzt - auch bei Polymorphie.

• `new`: Die Methode wird verdeckt - nur beim direkten Typ sichtbar.

Beispiel:

public class Basis
{
  public virtual void MachWas()
  {
    Console.WriteLine("Basis");
  }
}

public class KindMitOverride : Basis
{
  public override void MachWas()
  {
    Console.WriteLine("Override");
  }
}

public class KindMitNew : Basis
{
  public new void MachWas()
  {
    Console.WriteLine("New");
  }
}

public class Program
{
  public static void Main()
  {
    Basis a = new KindMitOverride();
    Basis b = new KindMitNew();

    a.MachWas();  // Ausgabe: Override
    b.MachWas();  // Ausgabe: Basis
  }
}

Bei Variable `a` wird tatsächlich die überschriebene Methode aufgerufen, obwohl der Datentyp `Basis` ist. Bei `b` läuft die Original-Methode - `new` verdeckt nur, ersetzt aber nicht.

Prüfungs-Tipp: Möchtest du, dass deine Methode immer aufgerufen wird - egal ob der Datentyp die Basis oder die abgeleitete Klasse ist? Dann nutze `override`. `new` verdeckt nur und kann Überraschungen verursachen.

Welche Anfängerfehler gibt es?

Fehler 1: `virtual` vergessen

// Falsch — compiliert nicht mit override
public class Basis
{
  public void MachWas() { }
}

public class Kind : Basis
{
  public override void MachWas() { }  // Fehler!
}

Das Überschreiben ohne `virtual` funktioniert nicht. Du musst entweder `virtual` in der Basisklasse ergänzen oder `new` verwenden.

Fehler 2: `override` vergessen

Wenn du `virtual` gesetzt hast, aber `override` weglässt, bekommst du eine Warnung vom Compiler. C# fragt dich: Soll das eine neue Methode sein oder willst du überschreiben? Sei explizit mit `override`.

Fehler 3: `base()` bei parametrisierten Konstruktoren vergessen

Hat die Basisklasse einen Konstruktor mit Parametern, musst du `: base(...)` aufrufen. Vergisst du das, compiliert der Code nicht. Der Compiler weiß nicht, welche Werte er an den Basiskonstruktor übergeben soll.

Fehler 4: Überschreiben mit `sealed` verhindern

Möchtest du verhindern, dass eine Klasse weiter überschreibt, nutzt du `sealed override`. Das ist besonders in Bibliotheken oder bei sicherheitsrelevantem Code wichtig.

public class Basis
{
  public virtual void Wichtig() { }
}

public class Mitte : Basis
{
  public sealed override void Wichtig() { }  // Weiteres Override verboten
}

Details zum `sealed`-Schlüsselwort findest du in der C#-Sprachreferenz.

Unterschied zu Java und Python

Falls du aus anderen Sprachen kommst:

• Java: Methoden sind automatisch `virtual`, außer sie sind `final`. Du brauchst kein Schlüsselwort. Für `base` nutzt Java `super` - siehe Java super Keyword.

• Python: Funktionen sind immer überschreibbar, es gibt kein `virtual`. Für `base` nutzt Python `super()` - siehe Python super().

• C#: Du musst `virtual` und `override` explizit angeben. Das ist mehr Tipparbeit, aber auch mehr Kontrolle.

Mehr dazu auch im Beitrag zum C# this Keyword.

FAQ: Häufige Fragen zu C# base virtual override

Kann ich `base` ohne `virtual` nutzen?

Nein, `base.Methodenname()` funktioniert nur, wenn die Methode in der Basisklasse mit `virtual` markiert und in der abgeleiteten Klasse überschrieben wurde. Ohne `virtual` gibt es keine Methode zum Überschreiben.

Was passiert, wenn ich `override` weglasse?

Der Compiler zeigt eine Warnung. C# fragt dich: Möchtest du überschreiben oder verdecken? Sei explizit mit `override` oder `new`.

Kann ich eine `override`-Methode erneut überschreiben?

Ja, standardmäßig sind `override`-Methoden automatisch wieder `virtual`. Möchtest du weitere Überschreibungen verhindern, markiere sie mit `sealed override`.

Was ist der Unterschied zwischen `base` und `this`?

`base` greift auf die Basisklasse zu, `this` auf die aktuelle Instanz. Mehr dazu im Artikel zu C# this.

Wo finde ich die offizielle Dokumentation?

Microsoft beschreibt Vererbung ausführlich auf Microsoft Learn - Vererbung in C#.

Fazit

Das Zusammenspiel von C# base virtual override ist die Grundlage für saubere Vererbung. `virtual` erlaubt Überschreibung, `override` führt sie aus und `base` holt dir die ursprüngliche Logik. Wer das verstanden hat, dem fallen auch komplexere Konzepte wie Polymorphie deutlich leichter - egal ob in der IHK-Prüfung, in der Programmieraufgabe an der Hochschule oder im ersten richtigen Projekt im Job.

Und wenn du das Ganze für dich nochmal durchgehen willst oder Unterstützung bei C#, Objektorientierung oder einem Projekt brauchst, findest du bei study-it.education IT-Nachhilfe, die sich genau an dich richtet.