Vererbung und Polymorphismus

Die Vererbung erlaubt es, neue Klassen auf Basis bestehender Klassen zu definieren. Die abgeleitete Klasse (Unterklasse, Subklasse) erbt alle Attribute und Methoden der Basisklasse (Oberklasse, Superklasse) und kann sie erweitern oder überschreiben. Vererbung modelliert eine Ist-eine-Beziehung: ein Hund ist ein Tier.

public class Tier {
    protected String name;

    public Tier(String name) { this.name = name; }

    public String laut() { return "..."; }   // wird überschrieben

    public String vorstellen() {
        return "Ich bin " + name + " und sage " + laut();
    }
}

public class Hund extends Tier {
    public Hund(String name) { super(name); }

    @Override
    public String laut() { return "Wuff!"; }
}

public class Katze extends Tier {
    public Katze(String name) { super(name); }

    @Override
    public String laut() { return "Miau!"; }
}

Das Schlüsselwort extends drückt die Vererbung aus, super(name) ruft den Oberklassen-Konstruktor auf, @Override markiert das Überschreiben.

Unter Polymorphismus versteht man, dass eine Variable vom Typ Tier sowohl ein Hund- als auch ein Katze-Objekt halten kann. Beim Aufruf von laut() wird zur Laufzeit die Methode der tatsächlichen Klasse aufgerufen – das nennt man dynamisches Binden.

Tier[] tiere = { new Hund("Bello"), new Katze("Mimi") };
for (Tier t : tiere) {
    System.out.println(t.vorstellen());
}
// Ich bin Bello und sage Wuff!
// Ich bin Mimi und sage Miau!

In Java sind alle nicht-statischen Methoden standardmäßig virtuell, also überschreibbar. Mit final kann man dies verbieten.

class Tier:
    def __init__(self, name):
        self.name = name

    def laut(self):
        return "..."

    def vorstellen(self):
        return f"Ich bin {self.name} und sage {self.laut()}"

class Hund(Tier):
    def laut(self):
        return "Wuff!"

class Katze(Tier):
    def laut(self):
        return "Miau!"

for t in [Hund("Bello"), Katze("Mimi")]:
    print(t.vorstellen())

In Python ist jede Methode automatisch überschreibbar; super().__init__(...) ruft den Oberklassen-Konstruktor auf.

Vererbung ermöglicht Wiederverwendung und Erweiterbarkeit: neue Tierarten lassen sich hinzufügen, ohne bestehenden Code zu ändern. Polymorphismus ist die Grundlage von Frameworks (z. B. Listen, die beliebige Objekttypen enthalten). In großen Projekten reduziert sie Redundanz drastisch.

Falsche Vererbungsrichtung (Hund erbt von Mensch), zu tiefe Hierarchien, vergessenes super(...) im Konstruktor, Überschreiben mit anderer Signatur (in Java würde das eine Überladung statt Überschreibung sein), und Verwechslung von Klassen- und Instanzkontext.

Zusammenfassung: Vererbung gibt einer Subklasse alle Attribute und Methoden der Oberklasse. Polymorphismus erlaubt es, überschriebene Methoden zur Laufzeit dynamisch aufzurufen.

Abitur-Tipp: Bei Polymorphismus-Aufgaben immer eine Tabelle anlegen: statischer Typ – dynamischer Typ – tatsächlich aufgerufene Methode.