Vererbung

Vererbung ist die zweite große Säule der OOP. Die Idee: anstatt eine neue Klasse von Grund auf zu bauen, basierst du sie auf einer bestehenden und erweiterst sie. Wenn du in L1 das Beispiel mit dem Sparbuch gesehen hast – das war Vererbung. Ein Sparbuch ist ein Konto – mit zusätzlichen Eigenschaften.

Diese Lektion zeigt dir wie Vererbung syntaktisch funktioniert, was vererbt wird und was nicht, wie du Methoden in Unterklassen überschreibst (Override), wann Vererbung sinnvoll ist und wann nicht (das ist überraschend wichtig!), und das berüchtigte Diamond-Problem bei Mehrfachvererbung.

1) Das Grundprinzip

Vererbung modelliert die „ist-ein"-Beziehung (englisch: is-a). Ein Dackel ist ein Hund. Ein Hund ist ein Säugetier. Ein Säugetier ist ein Tier. Diese Hierarchien gibt's überall in der Realität, und OOP bildet sie 1:1 ab:

Vererbungsbaum – klick die Knoten

Tier

name, gewicht

Hund

+ rasse

Katze

+ farbe

Dackel

+ kurzbeinig

Schäferhund

+ wachstrieb

Klick einen Knoten

Hier siehst du was vererbt wird und was die Unterklasse selbst beisteuert.

Die Klasse oben heißt Oberklasse, Elternklasse, Superklasse oder Basisklasse – alle Begriffe meinen dasselbe. Die abgeleiteten Klassen heißen Unterklasse, Kindklasse, Subklasse oder abgeleitete Klasse. Java nennt die Beziehung extends, Python und C# nutzen Klammern, C++ den Doppelpunkt. Konzept überall gleich.

2) Syntax in verschiedenen Sprachen

Die Syntax ist in jeder Sprache etwas anders, das Konzept ist gleich:

vererbung.pyPython

1class Tier:
2    def __init__(self, name):
3        self.name = name
4
5    def fressen(self):
6        print(f"{self.name} frisst.")
7
8class Hund(Tier):              # erbt von Tier
9    def __init__(self, name, rasse):
10        super().__init__(name)    # Eltern-Konstruktor
11        self.rasse = rasse
12
13    def bellen(self):
14        print(f"{self.name}: Wuff!")
15
16rex = Hund("Rex", "Dackel")
17rex.fressen()  # geerbt von Tier ✓
18rex.bellen()   # eigene Methode ✓

Hund.javaJava

1public class Tier {
2    protected String name;
3    public Tier(String name) { this.name = name; }
4    public void fressen() { System.out.println(name + " frisst"); }
5}
6
7public class Hund extends Tier {   // erbt von Tier
8    private String rasse;
9    public Hund(String name, String rasse) {
10        super(name);                  // Eltern-Konstruktor
11        this.rasse = rasse;
12    }
13    public void bellen() { System.out.println(name + ": Wuff!"); }
14}

Beachte das super(): damit ruft die Unterklasse den Konstruktor der Oberklasse auf. In Java muss super(...) die erste Zeile im Unterklassen-Konstruktor sein. In Python ist es Konvention.

3) Was wird vererbt?

Eine wichtige Frage: was bekommt die Unterklasse von der Oberklasse? Die Antwort hängt von der Sichtbarkeit ab (siehe L4):

Element der Oberklasse	Wird vererbt?
`public`-Methoden und -Felder	✓ ja, voll zugreifbar
`protected`-Methoden und -Felder	✓ ja, in Unterklassen zugreifbar
`private`-Methoden und -Felder	(✗) existieren im Objekt, sind aber für die Unterklasse nicht direkt zugreifbar
Konstruktoren	✗ nicht vererbt – Unterklasse muss eigenen schreiben
Statische Methoden und Felder	✓ technisch vererbt, aber Verhalten sprachenabhängig

Privat heißt: die Daten gehören dem Objekt, aber nur die Klasse die sie definiert hat darf darauf zugreifen. Die Unterklasse muss über öffentliche oder geschützte Methoden gehen.

4) Method Overriding

Eine Unterklasse kann Methoden der Oberklasse überschreiben – das heißt: gleichen Namen, andere Implementierung. Klassisches Beispiel: alle Tiere können „Laut geben", aber jedes Tier macht es anders.

override.pyPython

1class Tier:
2    def laut_geben(self):
3        print("Irgendein Laut")
4
5class Hund(Tier):
6    def laut_geben(self):     # ÜBERSCHRIEBEN
7        print("Wuff!")
8
9class Katze(Tier):
10    def laut_geben(self):     # ÜBERSCHRIEBEN
11        print("Miau!")
12
13Hund().laut_geben()    # Wuff!
14Katze().laut_geben()   # Miau!

In Java solltest du @Override als Annotation drüber setzen – nicht zwingend, aber sehr empfohlen. Sie hilft dem Compiler zu prüfen, dass du wirklich eine Methode der Oberklasse überschreibst und nicht versehentlich eine neue mit Tippfehler erfindest.

Das Überschreiben ist die Grundlage für Polymorphismus, der eigene Lektion L6 bekommt.

5) super() – auf den Eltern zugreifen

Manchmal willst du die Methode der Oberklasse nicht komplett ersetzen, sondern sie erweitern. Hier kommt super() ins Spiel – damit rufst du explizit die Eltern-Methode auf:

super_demo.pyPython

1class Mitarbeiter:
2    def __init__(self, name, gehalt):
3        self.name = name
4        self.gehalt = gehalt
5
6    def vorstellen(self):
7        print(f"Ich bin {self.name}")
8
9class Manager(Mitarbeiter):
10    def __init__(self, name, gehalt, team_groesse):
11        super().__init__(name, gehalt)  # Eltern initialisieren
12        self.team_groesse = team_groesse
13
14    def vorstellen(self):
15        super().vorstellen()              # Eltern-Verhalten
16        print(f"  Ich führe {self.team_groesse} Leute")

Manager erweitert die Vorstellung um eine zusätzliche Zeile. Ohne super().vorstellen() in Zeile 15 würde der „Ich bin {name}"-Teil verloren gehen. Das nennt sich Methodenerweiterung.

6) Method Resolution Order (MRO)

Was passiert wenn du eine Methode auf einer tief verschachtelten Klasse aufrufst? Python und Java suchen die Methode in einer bestimmten Reihenfolge. Beispiel mit Dackel → Hund → Tier:

Methoden-Auflösung bei dackel.fressen()

dackel.fressen() # Aufruf

Dackel

→

hat keine fressen()-Methode – weiter zur Oberklasse

Hund

→

hat auch keine fressen() – weiter

✓

Tier

→

hat fressen()! → wird ausgeführt

Die Suche geht bottom-up: erst die eigene Klasse, dann die Eltern, dann die Großeltern. Bei der ersten passenden Methode wird gestoppt. Das nennt sich Method Resolution Order (MRO).

In Python kannst du die MRO einsehen: Dackel.__mro__ oder Dackel.mro(). In Klausuren wird das gerne abgefragt – „in welcher Reihenfolge wird gesucht?".

7) Einfach- vs. Mehrfachvererbung

Manche Sprachen erlauben einer Klasse nur eine Oberklasse (Java, C#, Kotlin), andere lassen mehrere zu (Python, C++):

Einfachvererbung: eine Klasse hat genau eine direkte Oberklasse. Macht alles einfacher und vorhersehbarer.
Mehrfachvererbung: eine Klasse kann von mehreren Klassen gleichzeitig erben. Mächtig aber heikel.

multi.pyPython (Mehrfachvererbung)

1class Schwimmer:
2    def schwimmen(self): print("Schwimme...")
3
4class Flieger:
5    def fliegen(self): print("Fliege...")
6
7class Ente(Schwimmer, Flieger):  # beide!
8    pass
9
10e = Ente()
11e.schwimmen()  # aus Schwimmer
12e.fliegen()    # aus Flieger

8) Das Diamond-Problem

Bei Mehrfachvererbung kann ein klassisches Problem auftreten: das Diamond-Problem (Rauten-Problem). Eine Klasse erbt indirekt zweimal von derselben Basis-Klasse über zwei verschiedene Pfade:

Diamond-Problem: zwei Wege zum Vorfahr

Frage: wenn D eine Methode aufruft die A definiert hat, und B sowie C diese überschrieben haben – welche Version gewinnt? B oder C? Das ist nicht eindeutig!

Python-Lösung: C3 Linearization – algorithmische MRO die immer eine eindeutige Reihenfolge ergibt. Klassen-Reihenfolge in der Definition entscheidet: class D(B, C) – B vor C.

Java-Lösung: Mehrfachvererbung von Klassen ist VERBOTEN. Stattdessen Interfaces (siehe L7) – diese können mehrfach implementiert werden, aber haben keinen Zustand.

C++-Lösung: virtuelle Vererbung mit virtual-Keyword. Komplex und fehleranfällig.

Das Diamond-Problem ist der Hauptgrund warum viele moderne Sprachen Mehrfachvererbung von Klassen verbieten. Du wirst es in IHK-Prüfungen mit Diagramm bekommen – wichtig zu wissen.

9) IS-A vs. HAS-A

Ein wichtiger Modellierungs-Grundsatz: nicht jede Beziehung zwischen Klassen ist Vererbung. Es gibt zwei Hauptbeziehungen die oft verwechselt werden:

Die zwei wichtigsten Beziehungs-Typen

IS-A (ist-ein)

Wenn B wirklich ein spezialisierter Typ von A ist. Vererbung passt.

Dackel IS-A Hund
Manager IS-A Mitarbeiter
Auto IS-A Fahrzeug

HAS-A (hat-ein)

Wenn A einen B besitzt/enthält. Vererbung wäre falsch – nutze stattdessen Komposition (Attribut).

Auto HAS-A Motor
Person HAS-A Adresse
Bestellung HAS-A Kunde

Klassischer Anti-Pattern: class Auto extends Motor. Falsch! Ein Auto IST kein Motor, es HAT einen. Richtig: class Auto { private Motor motor; }. Das nennt sich Komposition – oft besser als Vererbung. Das Prinzip „Composition over Inheritance" ist in modernen Sprachen tonangebend.

10) Wann Vererbung – wann nicht?

Vererbung ist mächtig, aber wird in der Praxis oft überstrapaziert. Hier eine ehrliche Einschätzung:

Vererbung passt wenn:

Die Unterklasse wirklich ein Typ der Oberklasse ist (Liskov-Prinzip, siehe L9)
Die Hierarchie stabil und natürlich ist
Es Methoden gibt die in allen Unterklassen sinnvoll sind
Du Polymorphismus brauchst (gleichbehandeln verschiedener Subtypen)

Vererbung passt NICHT wenn:

Die Unterklasse mehrere Methoden der Oberklasse nicht braucht oder anders implementiert
Du nur Code wiederverwenden willst, aber keine echte Hierarchie modellierst
Die Beziehung „HAS-A" ist, nicht „IS-A"
Die Hierarchie absehbar instabil ist (Anforderungen ändern sich oft)

Modernes Mantra: „Composition over Inheritance". Im Zweifel Komposition (HAS-A) statt Vererbung (IS-A) bevorzugen. Vererbung ist eine starke Bindung – Composition ist flexibler und einfacher zu ändern. Mehr dazu in K49 Design Patterns.

Zusammenfassung

Vererbung modelliert die IS-A-Beziehung und ermöglicht Code-Wiederverwendung. Syntax: class B(A) in Python, extends in Java. Unterklassen erben public/protected Elemente, müssen aber eigenen Konstruktor schreiben. super() ruft den Eltern-Konstruktor oder Eltern-Methoden auf. Method Overriding ersetzt geerbte Methoden in der Unterklasse. Method Resolution Order: Suche bottom-up, erste passende Methode gewinnt. Mehrfachvererbung möglich in Python/C++, verboten in Java – wegen Diamond-Problem. Faustregel „Composition over Inheritance": im Zweifel HAS-A statt IS-A. Vererbung ist die Grundlage für Polymorphismus (L6).