Vererbung einfach erklärt – Ausbildung in der IT

Vererbung (englisch: Inheritance) ist eines der vier Grundprinzipien der objektorientierten Programmierung (OOP). Sie ermöglicht es, neue Klassen auf Basis bereits existierender Klassen zu erstellen. Die abgeleitete Klasse (Kindklasse) übernimmt dabei automatisch alle Eigenschaften und Methoden der Basisklasse (Elternklasse) und kann diese erweitern oder anpassen.

Grundkonzept der Vererbung

Die Vererbung basiert auf dem Prinzip, dass Objekte in der realen Welt hierarchisch klassifiziert werden können. Ein Hund ist beispielsweise ein spezielles Tier: Er besitzt alle allgemeinen Eigenschaften eines Tieres (wie Alter, Gewicht, kann fressen) plus zusätzliche hundespezifische Eigenschaften (wie Rasse, kann bellen). In der Programmierung bildet die Vererbung genau diese Beziehung ab.

Bei der Vererbung unterscheidet man zwei zentrale Begriffe:

Basisklasse (auch: Oberklasse, Elternklasse, Superklasse): Die Klasse, von der geerbt wird
Abgeleitete Klasse (auch: Unterklasse, Kindklasse, Subklasse): Die Klasse, die erbt und die Eigenschaften der Basisklasse übernimmt

Vorteile der Vererbung

Die Vererbung bietet mehrere entscheidende Vorteile für die Softwareentwicklung:

Code-Wiederverwendung: Einmal geschriebener Code muss nicht dupliziert werden. Gemeinsame Funktionalität wird in der Basisklasse definiert und automatisch an alle Kindklassen vererbt.
Redundanzvermeidung: Änderungen müssen nur an einer Stelle (in der Basisklasse) vorgenommen werden und wirken sich auf alle abgeleiteten Klassen aus.
Bessere Strukturierung: Der Code wird übersichtlicher und entspricht der natürlichen hierarchischen Denkweise.
Erweiterbarkeit: Neue Funktionalität kann durch Ableitung hinzugefügt werden, ohne bestehenden Code zu ändern.

Vererbung in verschiedenen Programmiersprachen

Die Syntax für Vererbung unterscheidet sich je nach Programmiersprache, das Grundprinzip bleibt jedoch gleich.

Vererbung in Java

In Java verwendet man das Schlüsselwort extends, um von einer Klasse zu erben:

// Basisklasse (Elternklasse)
public class Tier {
    protected String name;
    protected int alter;
    
    public Tier(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }
    
    public void fressen() {
        System.out.println(name + " frisst.");
    }
    
    public void schlafen() {
        System.out.println(name + " schläft.");
    }
}

// Abgeleitete Klasse (Kindklasse)
public class Hund extends Tier {
    private String rasse;
    
    public Hund(String name, int alter, String rasse) {
        super(name, alter);  // Aufruf des Eltern-Konstruktors
        this.rasse = rasse;
    }
    
    // Zusätzliche Methode nur für Hund
    public void bellen() {
        System.out.println(name + " bellt: Wuff!");
    }
}

Die Klasse Hund erbt alle Attribute und Methoden von Tier und fügt die eigene Methode bellen() hinzu. Mit super() wird der Konstruktor der Elternklasse aufgerufen.

Vererbung in C#

In C# wird Vererbung mit einem Doppelpunkt angegeben:

// Basisklasse
public class Fahrzeug {
    public string Marke { get; set; }
    public int Baujahr { get; set; }
    
    public virtual void Starten() {
        Console.WriteLine("Fahrzeug startet.");
    }
}

// Abgeleitete Klasse
public class Auto : Fahrzeug {
    public int AnzahlTueren { get; set; }
    
    // Überschreiben der Methode
    public override void Starten() {
        Console.WriteLine("Motor läuft. Auto ist startbereit.");
    }
    
    public void Hupen() {
        Console.WriteLine("Huuup!");
    }
}

Vererbung in Python

In Python wird die Basisklasse in Klammern hinter den Klassennamen geschrieben:

# Basisklasse
class Mitarbeiter:
    def __init__(self, name, gehalt):
        self.name = name
        self.gehalt = gehalt
    
    def arbeiten(self):
        print(f"{self.name} arbeitet.")

# Abgeleitete Klasse
class Entwickler(Mitarbeiter):
    def __init__(self, name, gehalt, programmiersprache):
        super().__init__(name, gehalt)  # Eltern-Konstruktor aufrufen
        self.programmiersprache = programmiersprache
    
    def programmieren(self):
        print(f"{self.name} programmiert in {self.programmiersprache}.")

Überschreiben von Methoden

Eine wichtige Eigenschaft der Vererbung ist das Überschreiben (Override) von Methoden. Eine Kindklasse kann eine geerbte Methode neu implementieren, um ein anderes Verhalten zu definieren. Dies ist die Grundlage für Polymorphie.

public class Tier {
    public void lautGeben() {
        System.out.println("Das Tier macht ein Geräusch.");
    }
}

public class Katze extends Tier {
    @Override
    public void lautGeben() {
        System.out.println("Miau!");
    }
}

public class Hund extends Tier {
    @Override
    public void lautGeben() {
        System.out.println("Wuff!");
    }
}

Durch das Überschreiben verhalten sich Katze und Hund unterschiedlich, obwohl beide von Tier erben. Die Annotation @Override in Java signalisiert dem Compiler, dass eine Methode überschrieben wird.

Generalisierung und Spezialisierung

Bei der Vererbung unterscheidet man zwei Denkrichtungen:

Generalisierung (Bottom-Up)

Bei der Generalisierung analysiert man bestehende Klassen und extrahiert gemeinsame Eigenschaften in eine neue Oberklasse. Wenn du beispielsweise die Klassen Hund, Katze und Vogel hast, erkennst du gemeinsame Attribute wie name, alter und Methoden wie fressen(). Diese fasst du in einer Oberklasse Tier zusammen.

Spezialisierung (Top-Down)

Bei der Spezialisierung startest du mit einer allgemeinen Klasse und leitest speziellere Varianten ab. Aus der Klasse Fahrzeug entstehen die spezialisierten Klassen Auto, Motorrad und LKW, die jeweils eigene Attribute und Methoden hinzufügen.

Einfache vs. Mehrfachvererbung

Je nach Programmiersprache gibt es unterschiedliche Vererbungsmodelle:

Vererbungstyp	Beschreibung	Unterstützt von
Einfache Vererbung	Eine Klasse erbt von genau einer Basisklasse	Java, C#, PHP
Mehrfachvererbung	Eine Klasse kann von mehreren Basisklassen erben	C++, Python
Interface-Vererbung	Klassen können mehrere Interfaces implementieren	Java, C#, TypeScript

Java und C# erlauben keine direkte Mehrfachvererbung von Klassen, da dies zu Konflikten führen kann (das sogenannte Diamond-Problem). Stattdessen können Klassen mehrere Interfaces implementieren, um ähnliche Flexibilität zu erreichen.

Zugriffsmodifikatoren und Vererbung

Die Sichtbarkeit von Attributen und Methoden beeinflusst, was eine Kindklasse erben und nutzen kann:

Modifikator	Zugriff in Kindklasse	Zugriff von außen
`public`	Ja	Ja
`protected`	Ja	Nein
`private`	Nein	Nein

Der Modifikator protected ist besonders bei Vererbung nützlich: Attribute sind für Kindklassen zugänglich, aber von außerhalb der Klassenhierarchie nicht sichtbar.

Vererbung und die anderen OOP-Prinzipien

Vererbung ist eng mit den anderen Grundprinzipien der OOP verknüpft:

Kapselung: Basisklassen kapseln gemeinsame Funktionalität und schützen interne Daten durch Zugriffsmodifikatoren.
Polymorphie: Durch Überschreiben von Methoden können abgeleitete Klassen unterschiedliche Verhaltensweisen zeigen, obwohl sie den gleichen Typ haben.
Abstraktion: Abstrakte Klassen definieren Schnittstellen, die von Kindklassen implementiert werden müssen.

Best Practices

Bei der Verwendung von Vererbung solltest du einige Grundsätze beachten:

“Ist-ein”-Beziehung prüfen: Vererbung sollte nur verwendet werden, wenn eine echte “ist-ein”-Beziehung besteht. Ein Hund “ist ein” Tier, das passt. Ein Auto “hat einen” Motor. Hier wäre Komposition besser.
Vererbungshierarchie flach halten: Tiefe Hierarchien mit vielen Ebenen werden schnell unübersichtlich und schwer wartbar.
Komposition vor Vererbung: Oft ist es flexibler, Objekte zu kombinieren, anstatt von ihnen zu erben.
Liskovsches Substitutionsprinzip: Objekte einer Kindklasse müssen überall einsetzbar sein, wo Objekte der Elternklasse erwartet werden.

Vererbung in der Praxis

Vererbung ist ein zentrales Konzept, das dir in vielen Bereichen der Softwareentwicklung begegnet:

GUI-Frameworks: Buttons, Textfelder und Labels erben von einer gemeinsamen Basis-Widget-Klasse
Spieleentwicklung: Verschiedene Spielfiguren erben von einer Character-Basisklasse
Web-Frameworks: Controller und Services erben oft von abstrakten Basisklassen
Datenbankzugriff: ORM-Frameworks nutzen Vererbung für Entity-Klassen

Wer als Fachinformatiker für Anwendungsentwicklung arbeitet, wird Vererbung regelmäßig einsetzen, sei es bei der Entwicklung eigener Klassenhierarchien oder bei der Arbeit mit bestehenden Frameworks.

Vererbung