Vererbung und Polymorphie
Diese Lektion führt dich Schritt für Schritt in die Mechanismen der Vererbung ein,
zeigt, wie man Code-Wiederverwendung auf elegante Weise erreicht
und erklärt, was Polymorphie praktisch bedeutet.
Am Ende wirst du verstehen, warum Begriffe wie
„eine Katze ist ein Tier“
nicht nur sprachlich, sondern auch im Code eine klare Bedeutung haben.
1. Motivation: Warum Vererbung?
Ohne Vererbung würdest du häufig denselben Code mehrfach schreiben.
Beispiel:
public class Hund {
String name;
int alter;
void essen() {
System.out.println(name + " frisst.");
}
}
public class Katze {
String name;
int alter;
void essen() {
System.out.println(name + " frisst.");
}
}
→ Beide Klassen haben die gleichen Attribute und Methoden.
→ Das ist unnötige Dopplung – und schwer zu warten.
Die Lösung:
Erzeuge eine gemeinsame Oberklasse, die den gemeinsamen Code enthält.
Grundprinzip der Vererbung
Vererbung bedeutet, dass eine Klasse (Kindklasse)
alle Eigenschaften und Methoden einer anderen Klasse (Elternklasse) erbt.
public class Tier {
String name;
int alter;
void essen() {
System.out.println(name + " frisst.");
}
}
public class Hund extends Tier {
void bellen() {
System.out.println(name + " bellt: Wuff!");
}
}
extends = „erweitert um“
→ Hund erbt automatisch alles von Tier.
→ Neue Methoden wie bellen() kommen zusätzlich hinzu.
3. Verwendung
public class Main {
public static void main(String[] args) {
Hund h1 = new Hund();
h1.name = "Ava";
h1.alter = 4;
h1.essen(); // geerbt von Tier
h1.bellen(); // eigene Methode
}
}
Ausgabe:
Ava frisst.
Ava bellt: Wuff!
Hierarchie und „ist-ein“-Beziehung
In Java gilt:
Eine Unterklasse ist immer auch eine Instanz der Oberklasse.
Das heißt:
Jeder
Hundist einTier.Aber nicht jedes
Tierist einHund.
Beispiel:
Tier t1 = new Hund(); // erlaubt
Hund h1 = new Tier(); // verboten
Überschreiben von Methoden (Override)
Unterklassen können geerbte Methoden überschreiben,
um ihr Verhalten anzupassen.
public class Katze extends Tier {
@Override
void essen() {
System.out.println(name + " frisst leise.");
}
}
Verwendung:
public class Main {
public static void main(String[] args) {
Hund h1 = new Hund();
h1.name = "Ava";
Katze k1 = new Katze();
k1.name = "Luna";
h1.essen(); // Ava frisst.
k1.essen(); // Luna frisst leise.
}
}
→ Obwohl beide essen() aufrufen,
reagieren sie unterschiedlich – das ist der Kern von Polymorphie.
Polymorphie – was bedeutet das?
„Poly“ = viele, „Morph“ = Gestalt → Vielgestaltigkeit
Ein Objekt kann mehrere Formen annehmen:
Ein
Hundist auch einTier.Du kannst
Tier-Referenzen verwenden, die aber auf verschiedene Unterklassen zeigen.
public class Main {
public static void main(String[] args) {
Tier t1 = new Hund();
Tier t2 = new Katze();
t1.name = "Ava";
t2.name = "Luna";
t1.essen(); // Ava frisst.
t2.essen(); // Luna frisst leise.
}
}
→ Obwohl beide Variablen vom Typ Tier sind,
führt Java zur Laufzeit die richtige Methode aus – abhängig vom tatsächlichen Objekttyp.
Das nennt man dynamisches Binden oder late binding.
super – Zugriff auf die Elternklasse
Wenn du eine Methode überschreibst, kannst du mit super
trotzdem auf die ursprüngliche Version zugreifen.
public class Katze extends Tier {
@Override
void essen() {
super.essen(); // ruft Tier.essen() auf
System.out.println(name + " schleckt danach ihre Pfote.");
}
}
Ausgabe:
Luna frisst.
Luna schleckt danach ihre Pfote.
Konstruktoren und Vererbung
Konstruktoren werden nicht vererbt,
aber beim Erzeugen eines Objekts einer Unterklasse
wird automatisch zuerst der Konstruktor der Elternklasse aufgerufen.
public class Tier {
public Tier() {
System.out.println("Tier wird erzeugt.");
}
}
public class Hund extends Tier {
public Hund() {
System.out.println("Hund wird erzeugt.");
}
}
public class Main {
public static void main(String[] args) {
Hund h = new Hund();
}
}
Ausgabe:
Tier wird erzeugt.
Hund wird erzeugt.
→ Die Elternklasse wird immer zuerst initialisiert.
Interaktive Visualisierung: Vererbung und Polymorphie
Diese Visualisierung zeigt, wie verschiedene Tiere auf denselben Methodenaufruf unterschiedlich reagieren.
Interaktive Visualisierung: Tiere und Polymorphie
– Ausgabe der Java-Konsole –
Häufige Fehlerquellen
| Fehler | Ursache | Lösung |
|---|---|---|
Cannot assign parent to child | Tier t = new Tier(); Hund h = t; nicht erlaubt | Nur Oberklasse → Unterklasse geht nicht |
Missing super() | Elternklasse hat keinen parameterlosen Konstruktor | Mit super(wert) im Kind-Konstruktor aufrufen |
| Methode nicht überschrieben | Schreibfehler oder Signatur anders | Immer @Override verwenden, um Tippfehler zu erkennen |
| Keine Polymorphie sichtbar | Methode in Elternklasse nicht überschrieben | Sicherstellen, dass die Kindklasse @Override nutzt |