# Vererbung und Polymorphie in der OOP

> Vererbung erlaubt es, eine neue Klasse (Unterklasse) von einer bestehenden (Oberklasse) abzuleiten und deren Attribute und Methoden zu übernehmen. So vermeidet man doppelten Code. Polymorphie bedeutet Vielgestaltigkeit: Dieselbe Methode kann in verschiedenen Unterklassen unterschiedlich umgesetzt sein, und der aufrufende Code muss nicht wissen, welche konkrete Klasse dahintersteckt.

**Autor:** Mr. Benjamin · **Beruf:** IT-Grundlagen
**Veröffentlicht:** 2026-09-22 · **Aktualisiert:** 2026-09-22
**Quelle:** https://yellowbluetech.de/blog/vererbung-polymorphie

---

Eine `Katze` und ein `Hund` sind beide `Tiere` – sie haben einen Namen, ein Alter und geben einen Laut von sich. Diese natürliche „ist ein"-Beziehung bildet die objektorientierte Programmierung mit Vererbung ab. Zusammen mit Polymorphie ist sie das Herzstück der OOP.

## Vererbung: gemeinsames nach oben

Vererbung leitet eine **Unterklasse** aus einer **Oberklasse** ab. Die Unterklasse übernimmt deren Attribute und Methoden und ergänzt oder verändert eigene.

```text
Tier            (Oberklasse: name, alter, gibLaut())
 ├── Hund       (Unterklasse: gibLaut() = "Wuff")
 └── Katze      (Unterklasse: gibLaut() = "Miau")
```

> **Merksatz**
>
> Die Leitfrage für Vererbung ist die **„ist ein"-Beziehung**: Ein Hund *ist ein* Tier → Vererbung passt. Ein Auto *hat einen* Motor → das ist keine Vererbung, sondern eine Beziehung zwischen Objekten. Vererbung vermeidet doppelten Code, weil Gemeinsames nur **einmal** in der Oberklasse steht.

## Überschreiben von Methoden

Eine Unterklasse kann eine geerbte Methode **überschreiben** (englisch *override*), um sie anders umzusetzen. `Hund` und `Katze` erben `gibLaut()`, füllen sie aber unterschiedlich.

Nicht zu verwechseln mit **Überladen** (*overload*): Das ist dieselbe Methode mit **unterschiedlichen Parametern** in derselben Klasse.

## Polymorphie: eine Schnittstelle, viele Formen

Polymorphie („Vielgestaltigkeit") bedeutet: Der aufrufende Code arbeitet mit dem **Typ der Oberklasse** und muss nicht wissen, welche konkrete Unterklasse dahintersteckt.

```text
für jedes tier in tierliste:
    tier.gibLaut()     // Hund → "Wuff", Katze → "Miau"
```

Dieselbe Anweisung `tier.gibLaut()` verhält sich je nach tatsächlichem Objekt unterschiedlich – zur Laufzeit wird die passende Methode gewählt.

> **Prüfungstipp**
>
> Häufig verwechselt: **Überschreiben (override)** = gleiche Signatur, andere Umsetzung in der Unterklasse; **Überladen (overload)** = gleicher Methodenname, andere Parameterliste. Und: **Polymorphie** ist der Effekt, dass derselbe Aufruf je nach Objekt anders reagiert. Diese drei Begriffe sauber auseinanderzuhalten, wird regelmäßig geprüft. Erklärung idealerweise am Tier-Beispiel.

## Warum das nützt

> **Hinweis**
>
> Vererbung und Polymorphie machen Code **erweiterbar**, ohne Bestehendes umzubauen: Kommt ein neues Tier `Vogel` dazu, erbt es von `Tier` und definiert nur sein eigenes `gibLaut()` – die Schleife über die Tierliste bleibt unverändert. Das ist einer der größten Vorteile der [objektorientierten Programmierung](/blog/oop-grundlagen) gegenüber rein prozeduralem Code. In [UML-Klassendiagrammen](/blog/uml-diagramme-grundlagen) wird Vererbung mit einem Pfeil mit hohler Spitze zur Oberklasse dargestellt.

## Selbstkontrolle

**Frage:** Eine Unterklasse ersetzt eine geerbte Methode durch eine eigene Umsetzung mit gleicher Signatur. Wie heißt das?

- [x] Überschreiben (override)
- [ ] Überladen (overload)
- [ ] Kapselung
- [ ] Instanziierung

**Erklärung:** Das ist Überschreiben (override): gleiche Methodensignatur wie in der Oberklasse, aber andere Umsetzung in der Unterklasse. Überladen wäre derselbe Methodenname mit anderer Parameterliste – das hat mit Vererbung nichts zu tun.

## Häufige Fragen

### Was ist der Unterschied zwischen 'ist ein' und 'hat ein'?

„Ist ein" beschreibt eine Vererbungsbeziehung: Ein Hund ist ein Tier, also erbt Hund von Tier. „Hat ein" beschreibt dagegen, dass ein Objekt ein anderes enthält oder nutzt, etwa ein Auto hat einen Motor. Für „hat ein" nutzt man keine Vererbung, sondern verweist von einem Objekt auf ein anderes (Komposition oder Aggregation).

### Was ist eine abstrakte Klasse?

Eine abstrakte Klasse ist eine Oberklasse, von der man keine Objekte erzeugen kann, weil sie nur als Bauplan dient. Sie kann Methoden vorschreiben, deren konkrete Umsetzung die Unterklassen liefern müssen. So erzwingt man eine gemeinsame Struktur, etwa dass jedes Tier ein gibLaut() haben muss.

### Wozu braucht man Polymorphie konkret?

Sie erlaubt Code, der mit vielen verschiedenen Typen umgeht, ohne sie einzeln zu unterscheiden. Statt für jedes Tier ein eigenes if zu schreiben, ruft man einfach gibLaut() auf und die richtige Umsetzung wird automatisch gewählt. Das hält den Code kurz und leicht erweiterbar.

### Kann eine Klasse von mehreren Oberklassen erben?

Das hängt von der Sprache ab. Manche erlauben Mehrfachvererbung, andere wie Java bewusst nicht, weil sie zu Mehrdeutigkeiten führen kann. Stattdessen nutzt man dort Schnittstellen (Interfaces), um Verhalten aus mehreren Quellen zu kombinieren. Für die Grundlagen genügt die einfache Vererbung.

**Weiterlesen:** [Fehlerbehandlung mit Exceptions](/blog/fehlerbehandlung-exceptions) · [Softwaretests: von Unit-Test bis Abnahme](/blog/softwaretests-grundlagen) · [Datenstrukturen: Array, Liste, Stack und Queue](/blog/datenstrukturen-grundlagen)

## Das Wichtigste in Kürze

- **Vererbung**: Unterklasse übernimmt Attribute/Methoden der Oberklasse („ist ein").
- **Überschreiben** (override): gleiche Signatur, andere Umsetzung in der Unterklasse.
- **Überladen** (overload): gleicher Name, andere Parameter – nicht verwechseln.
- **Polymorphie**: derselbe Aufruf verhält sich je nach Objekt unterschiedlich.
- Ergebnis: Code wird **erweiterbar**, ohne Bestehendes umzubauen.