Welche der folgenden Beziehungen rechtfertigt Vererbung (is-a)?

Richtige Antwort: Hund und Tier. Vererbung modelliert 'ist ein' (is-a). 'Hund ist ein Tier' ✓. Die anderen sind 'hat ein' (has-a) — Komposition wäre richtig: Auto hat einen Motor, Mensch hat eine Adresse.

Was passiert, wenn eine Subklasse eine Methode der Basisklasse mit gleicher Signatur definiert?

Richtige Antwort: Die neue Methode überschreibt die alte (Override). Das ist **Override**: gleiche Signatur in der Subklasse ersetzt die geerbte Methode. Bei Aufrufen auf einer Subklassen-Instanz wird die neue Version genommen — egal ob die Variable als Sub- oder Basisklasse deklariert ist (dynamischer Dispatch).

In Java: was bewirkt super(name, alter) im Konstruktor einer Subklasse?

Richtige Antwort: Ruft den Konstruktor der Basisklasse auf, um geerbte Felder zu initialisieren. super(...) ruft den Konstruktor der Basisklasse mit den angegebenen Argumenten auf. Damit werden die geerbten Felder ordentlich initialisiert. Konstruktoren werden NICHT geerbt, daher braucht jede Subklasse einen eigenen.

Was gibt bello.machGeraeusch() aus, wenn Hund machGeraeusch() überschreibt mit 'Wuff!'?

Richtige Antwort: Wuff! — weil dynamischer Dispatch den echten Typ Hund nimmt. Polymorphie / dynamischer Dispatch: Java guckt zur Laufzeit auf den ECHTEN Typ des Objekts (Hund), nicht auf die Variablen-Deklaration (Tier). Hund hat machGeraeusch() überschrieben → 'Wuff!' wird ausgegeben.

Eine Klasse ist als abstract deklariert. Was bedeutet das?

Richtige Antwort: Sie kann nicht direkt instantiiert werden — nur konkrete Subklassen können es. abstract heißt: kein direktes 'new'. Die Klasse beschreibt ein Konzept, das erst durch konkrete Subklassen Form annimmt. Sie kann sehr wohl Felder und Methoden haben — und meist auch abstract-Methoden, die Subklassen implementieren MÜSSEN.

Was passiert beim Method-Dispatch, wenn die Methode weder in der konkreten Klasse noch in einer Basisklasse existiert?

Richtige Antwort: Compile-Fehler in Java, AttributeError zur Laufzeit in Python. In Java findet der Compiler den Aufruf gar nicht erst zulässig — Build schlägt fehl. In Python merkt's der Interpreter erst zur Laufzeit (AttributeError), weil Python dynamisch typisiert ist. So oder so: kein automatisches Erstellen, kein null.

Warum erlaubt Java keine Mehrfachvererbung von Klassen (also nicht class C extends A, B)?

Richtige Antwort: Wegen des Diamant-Problems: Konflikt, wenn A und B beide eine Methode m() haben — welche soll C erben?. Diamant-Problem: erbt C von A und B, und beide haben m(), welche soll gelten? Java sagt: gar keine — Mehrfachvererbung von Klassen verboten. Stattdessen: Interfaces (mehrere erlaubt, da sie ursprünglich keinen Body hatten). Python erlaubt's und löst per MRO.

Was ist Polymorphie in einem Satz?

Richtige Antwort: Eine Variable vom Basisklassen-Typ kann sich je nach echtem Objekttyp unterschiedlich verhalten. Polymorphie = 'viele Formen'. Eine Tier-Variable kann ein Hund, eine Katze, ein Vogel sein — bei einem Methodenaufruf wird die jeweils passende Override-Version ausgeführt. Das macht Code flexibel: gleicher Aufruf, unterschiedliches Verhalten je nach Typ.

UniProMax/Programmiergrundlagen/vererbung-polymorphie

Programmiergrundlagen·14 Min Lesezeit·Fortgeschritten

Vererbung & Polymorphie

Eine Klasse erbt von einer anderen: gemeinsamer Code wandert nach oben, Spezifisches bleibt unten. Override, super, dynamischer Dispatch — das Fundament für jede OOP-Architektur. Mit Tier-Hierarchie-Visualizer.

Voraussetzung:Klassen und Objekte

Sprache wählen

Sprache

Lerneinheit 1 von 3java + python

Vererbung & Polymorphie

Vererbung ermöglicht es, eine Klasse von einer anderen abzuleiten und ihre Eigenschaften und Methoden zu übernehmen. Polymorphie heißt: derselbe Methodenaufruf verhält sich unterschiedlich, je nachdem welche konkrete Klasse das Objekt hat. Zusammen sind sie die zwei zentralen OOP-Mechanismen die in jeder Klausur abgefragt werden.

Was du können musst:

extends (Java): class Hund extends Tier macht Hund zur Subklasse von Tier
super: Aufruf der Konstruktor- oder Methoden-Implementierung der Oberklasse
Override: Subklasse ersetzt eine Methode der Oberklasse, oft mit @Override-Annotation
abstract: Klasse oder Methode kann nicht direkt instanziiert werden, dient nur als Vorlage
Polymorphie: Variable vom Typ Tier kann auf ein Hund-Objekt zeigen, ruft dann Hund-Methoden

In Klausuren wirst du oft gefragt: welche Methode wird aufgerufen? wenn eine Variable vom Obertyp auf ein Subtyp-Objekt zeigt. Antwort: immer die Methode der konkreten Klasse (dynamisches Binden), nicht die der deklarierten Variable.

Du programmierst eine Tier-App. Du hast schon eine Klasse Hund:

class Hund {
    String name;
    int alter;
    void schlafen() { System.out.println("Zzz..."); }
    void machGeraeusch() { System.out.println("Wuff!"); }
}

Jetzt brauchst du Katze. Schreibst du die ganze Klasse nochmal? Mit name, alter, schlafen() — nochmal alles?

Vererbung sagt: nein. Pack das Gemeinsame in eine Basisklasse Tier, lass Hund und Katze davon erben.

class Tier {
    String name;
    int alter;
    void schlafen() { System.out.println("Zzz..."); }
}

class Hund extends Tier {
    void machGeraeusch() { System.out.println("Wuff!"); }
}

class Katze extends Tier {
    void machGeraeusch() { System.out.println("Miau"); }
}

Hund hat jetzt automatisch name, alter und schlafen() — geerbt von Tier. Plus seine eigene Methode machGeraeusch().

Das ist die Grundidee: gemeinsamer Code wandert nach oben, jede Unterklasse fügt nur ihr Spezifisches dazu.

Begriff	Was es bedeutet	Beispiel
Basisklasse / Superklasse / Parent	Die Klasse oben in der Hierarchie	`Tier`
Subklasse / Unterklasse / Child	Die Klasse, die erbt	`Hund`, `Katze`
extends (Java) / Klammern (Python)	Vererbungs-Syntax	`class Hund extends Tier`
Vererbung	Subklasse bekommt automatisch alle Felder + Methoden der Basisklasse	Hund hat `name`
Override	Subklasse ersetzt eine geerbte Methode mit eigener Version	Hund.machGeraeusch()
super (Java) / super() (Python)	Zugriff auf die Methode/Konstruktor der Basisklasse	`super(name, alter)`
is-a Beziehung	"Ein Hund ist ein Tier" — Faustregel für Vererbung	Hund is-a Tier ✓, Hund is-a Auto ✗

Vererbung modelliert "ist ein". Wenn du nicht sagen kannst "X ist ein Y", dann gehört X auch nicht in Y rein.

class Tier {
    String name;
    int alter;

    Tier(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }

    void schlafen() {
        System.out.println(name + " schläft: Zzz...");
    }

    void machGeraeusch() {
        System.out.println("(unspezifisches Geräusch)");
    }
}

class Hund extends Tier {
    String rasse;

    Hund(String name, int alter, String rasse) {
        super(name, alter);   // Konstruktor der Basisklasse aufrufen
        this.rasse = rasse;
    }

    @Override
    void machGeraeusch() {     // überschreibt Tier.machGeraeusch()
        System.out.println(name + ": Wuff!");
    }
}

// Nutzung
Hund bello = new Hund("Bello", 4, "Labrador");
bello.schlafen();         // → "Bello schläft: Zzz..."  (geerbt von Tier)
bello.machGeraeusch();    // → "Bello: Wuff!"           (von Hund überschrieben)

In Python:

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

    def schlafen(self):
        print(f"{self.name} schläft: Zzz...")

    def mach_geraeusch(self):
        print("(unspezifisches Geräusch)")


class Hund(Tier):
    def __init__(self, name, alter, rasse):
        super().__init__(name, alter)
        self.rasse = rasse

    def mach_geraeusch(self):
        print(f"{self.name}: Wuff!")


bello = Hund("Bello", 4, "Labrador")
bello.schlafen()        # → "Bello schläft: Zzz..."
bello.mach_geraeusch()  # → "Bello: Wuff!"

super() ist der Schlüssel: damit ruft die Subklasse die Methode der Basisklasse auf — typischerweise im Konstruktor, um Felder der Basisklasse zu setzen.

Stell dir vor du rufst bello.machGeraeusch() auf. Welche Methode läuft?

Regel: Schau zuerst in der konkreten Klasse der Instanz (also Hund), dann wandere die Hierarchie hoch zur nächsten Basisklasse.

bello.machGeraeusch()
  ↓
1. Hat Hund eine machGeraeusch()?  → Ja → AUSFÜHREN ("Wuff!")

bello.schlafen()
  ↓
1. Hat Hund eine schlafen()?       → Nein
2. Hat Tier eine schlafen()?       → Ja → AUSFÜHREN ("Zzz...")

bello.fliegen()
  ↓
1. Hat Hund fliegen()?              → Nein
2. Hat Tier fliegen()?              → Nein
3. Compile-Fehler! (Java)
   AttributeError! (Python)

Erst die spezifischste Klasse, dann nach oben — die erste passende Methode gewinnt.

Im Interaktiv-Tab kannst du das live durchspielen: einer Hund-Variable kannst du fliegen() nicht aufrufen — der Compiler stoppt dich.

Das ist der wirkliche Trick. Du kannst eine Variable vom Typ Tier haben, die in Wirklichkeit einen Hund speichert:

Tier x = new Hund("Bello", 4, "Labrador");
x.machGeraeusch();   // → "Bello: Wuff!"

Was? x ist als Tier deklariert, aber Wuff! kommt raus? Ja — das ist dynamischer Dispatch:

Welche Methode aufgerufen wird, entscheidet der echte Typ des Objekts (Hund), nicht der deklarierte Typ der Variable (Tier).

Das nennt man Polymorphie — "viele Formen". Eine Tier-Variable kann verschiedene Formen annehmen (Hund, Katze, Vogel) und sich entsprechend verhalten.

Tier[] zoo = {
    new Hund("Bello", 4, "Labrador"),
    new Katze("Whiskers", 3),
    new Vogel("Tweety", 2)
};

for (Tier t : zoo) {
    t.machGeraeusch();  // jedes Tier sein eigenes Geräusch
}
// Output:
//   Bello: Wuff!
//   Whiskers: Miau
//   Tweety: Tschilp

Polymorphie ist der Hauptgrund warum Vererbung mächtig ist: gleicher Code, unterschiedliches Verhalten je nach echtem Typ.

In Java schreibt man @Override über eine überschriebene Methode. Das ist optional, aber stark empfohlen — der Compiler prüft, dass die Methode wirklich existiert in der Basisklasse.

class Hund extends Tier {
    @Override
    void machGeraeusch() {  // Compiler: passt das zu Tier.machGeraeusch()? Ja!
        System.out.println("Wuff!");
    }
}

Verschreibst du dich (mach_Geraeusch() mit Tippfehler), wird ohne @Override einfach eine neue Methode angelegt — Bug auf Lebenszeit. Mit @Override schreit der Compiler.

In Python gibt's kein direktes Pendant (Convention: # overrides Tier.mach_geraeusch als Kommentar).

super. innerhalb einer Override

Manchmal willst du das alte Verhalten ergänzen, nicht ersetzen:

class Hund extends Tier {
    @Override
    void schlafen() {
        super.schlafen();              // Tier.schlafen() rufen
        System.out.println("(im Korb)");
    }
}
// Hund.schlafen() → "Bello schläft: Zzz..." + "(im Korb)"

super.methode() heißt: "Ruf die Version der Basisklasse auf." Häufig in Konstruktoren (super(name, alter)) und beim Erweitern statt Ersetzen.

Manchmal soll die Basisklasse erzwingen, dass jede Subklasse eine bestimmte Methode hat — ohne selbst zu wissen, was die tut.

abstract class Tier {
    String name;

    abstract void machGeraeusch();   // kein Body — MUSS in Subklasse implementiert werden

    void schlafen() {                 // normal, kann geerbt werden
        System.out.println(name + " schläft");
    }
}

class Hund extends Tier {
    @Override
    void machGeraeusch() {
        System.out.println("Wuff!");  // Pflicht: Compiler erzwingt es
    }
}

new Tier();   // FEHLER: kann nicht instantiiert werden, Tier ist abstract
new Hund();   // OK

Eine abstrakte Klasse kann nicht direkt instantiiert werden — nur ihre konkreten Subklassen. Sie definiert ein Pflichtprogramm.

Trick 1 — is-a vs has-a: Vererbung ist "ist ein". Wenn du eher sagen würdest "hat ein", brauchst du Komposition (Feld vom Typ X), nicht Vererbung.

Hund is-a Tier         ✓ → Vererbung
Auto has-a Motor       ✓ → Komposition (Auto hat ein Motor-Feld)
Auto is-a Motor        ✗ → falsche Modellierung

Trick 2 — Override-Regel: Eine Methode in der Subklasse überschreibt nur, wenn:

gleicher Name
gleiche Parameter (sonst ist es eine Überladung, anderes Konzept)
gleicher oder kompatibler Rückgabetyp

Trick 3 — Konstruktor wird NICHT geerbt. Du musst in der Subklasse einen eigenen Konstruktor schreiben und mit super(...) den Basis-Konstruktor aufrufen.

Trick 4 — Default ist nicht polymorph in C++, aber in Java/Python schon. In Java sind alle Methoden virtuell (außer final/static/private). Klausur-Frage: "ist equals() in Java polymorph?" → Ja.

Trick 5 — Diamant-Problem: Mehrfachvererbung (eine Klasse erbt von zwei) ist in Java verboten (nur 1 extends), in Python erlaubt (MRO-Algorithmus löst Konflikte). Klausur-Frage: "Warum hat Java keine Mehrfachvererbung von Klassen?" → wegen Diamant-Problem.

Trick 6 — Java spezifisch: Object ist Vater aller Klassen. Jede Klasse erbt implizit von java.lang.Object — daher hat jedes Objekt toString(), equals(), hashCode().

Trick 7 — instanceof: prüft den echten Typ zur Laufzeit:

Tier t = new Hund(...);
t instanceof Hund   // true — echter Typ ist Hund
t instanceof Tier   // true — Hund ist auch ein Tier (Vererbungskette)
t instanceof Katze  // false

GUI-Frameworks: Button extends Widget, TextField extends Widget — alle haben render() polymorph
Game-Entwicklung: Enemy extends GameObject, viele Enemy-Subtypes mit eigenem update()
Servlets / Spring: MyController extends BaseController mit überschriebenen Endpoints
Sammlungen: ArrayList implements List, LinkedList implements List — gleiches Interface, andere Implementierung
Streams in Java: FileInputStream extends InputStream, BufferedInputStream extends InputStream

Faustregel: Wenn du in der Klausur sagen sollst, ob Vererbung passt — frag dich "ist X ein Y?" Wenn ja, vererbe. Wenn nein, finde was anderes (Komposition, Interface, etc.).

Klausur-ÜbersichtKomplette Übersicht: alle Tabs als linearer Text zum Lernen

Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur — und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).

Teil 1·Erklärung

Erklärung

Vererbung & Polymorphie

Mehr aus Programmiergrundlagen

Programmiergrundlagen

Variablen und Datentypen

Wie speichert ein Programm Werte? Wie unterscheiden sich int, double, String und boolean?

Programmiergrundlagen

Bedingungen

if, else, else if. Wie trifft ein Programm Entscheidungen, und welche Vergleichsoperatoren brauchst du?

Programmiergrundlagen

Schleifen

for, while, Iteration. Wie wiederhole ich Code, ohne mich zu verzetteln?

Was du danach lernen kannst

Folge-TopicException HandlingAnschauen

Vererbung & Polymorphie

Was du können musst:

extends (Java): class Hund extends Tier macht Hund zur Subklasse von Tier

super: Aufruf der Konstruktor- oder Methoden-Implementierung der Oberklasse

Override: Subklasse ersetzt eine Methode der Oberklasse, oft mit @Override-Annotation

abstract: Klasse oder Methode kann nicht direkt instanziiert werden, dient nur als Vorlage

Polymorphie: Variable vom Typ Tier kann auf ein Hund-Objekt zeigen, ruft dann Hund-Methoden

class Tier { String name; int alter; void schlafen() { System.out.println("Zzz..."); } } class Hund extends Tier { void machGeraeusch() { System.out.println("Wuff!"); } } class Katze extends Tier { void machGeraeusch() { System.out.println("Miau"); } }

Begriff

Was es bedeutet

Beispiel

Basisklasse / Superklasse / Parent

Die Klasse oben in der Hierarchie

Tier

Subklasse / Unterklasse / Child

Die Klasse, die erbt

Hund, Katze

extends (Java) / Klammern (Python)

Vererbungs-Syntax

class Hund extends Tier

Vererbung

Subklasse bekommt automatisch alle Felder + Methoden der Basisklasse

Hund hat name

Override

Subklasse ersetzt eine geerbte Methode mit eigener Version

Hund.machGeraeusch()

super (Java) / super() (Python)

Zugriff auf die Methode/Konstruktor der Basisklasse

super(name, alter)

is-a Beziehung

"Ein Hund ist ein Tier" — Faustregel für Vererbung

Hund is-a Tier ✓, Hund is-a Auto ✗

class Tier { String name; int alter; Tier(String name, int alter) { this.name = name; this.alter = alter; } void schlafen() { System.out.println(name + " schläft: Zzz..."); } void machGeraeusch() { System.out.println("(unspezifisches Geräusch)"); } } class Hund extends Tier { String rasse; Hund(String name, int alter, String rasse) { super(name, alter); // Konstruktor der Basisklasse aufrufen this.rasse = rasse; } @Override void machGeraeusch() { // überschreibt Tier.machGeraeusch() System.out.println(name + ": Wuff!"); } } // Nutzung Hund bello = new Hund("Bello", 4, "Labrador"); bello.schlafen(); // → "Bello schläft: Zzz..." (geerbt von Tier) bello.machGeraeusch(); // → "Bello: Wuff!" (von Hund überschrieben)

class Tier: def __init__(self, name, alter): self.name = name self.alter = alter def schlafen(self): print(f"{self.name} schläft: Zzz...") def mach_geraeusch(self): print("(unspezifisches Geräusch)") class Hund(Tier): def __init__(self, name, alter, rasse): super().__init__(name, alter) self.rasse = rasse def mach_geraeusch(self): print(f"{self.name}: Wuff!") bello = Hund("Bello", 4, "Labrador") bello.schlafen() # → "Bello schläft: Zzz..." bello.mach_geraeusch() # → "Bello: Wuff!"

bello.machGeraeusch() ↓ 1. Hat Hund eine machGeraeusch()? → Ja → AUSFÜHREN ("Wuff!") bello.schlafen() ↓ 1. Hat Hund eine schlafen()? → Nein 2. Hat Tier eine schlafen()? → Ja → AUSFÜHREN ("Zzz...") bello.fliegen() ↓ 1. Hat Hund fliegen()? → Nein 2. Hat Tier fliegen()? → Nein 3. Compile-Fehler! (Java) AttributeError! (Python)

Tier[] zoo = { new Hund("Bello", 4, "Labrador"), new Katze("Whiskers", 3), new Vogel("Tweety", 2) }; for (Tier t : zoo) { t.machGeraeusch(); // jedes Tier sein eigenes Geräusch } // Output: // Bello: Wuff! // Whiskers: Miau // Tweety: Tschilp

class Hund extends Tier { @Override void schlafen() { super.schlafen(); // Tier.schlafen() rufen System.out.println("(im Korb)"); } } // Hund.schlafen() → "Bello schläft: Zzz..." + "(im Korb)"

abstract class Tier { String name; abstract void machGeraeusch(); // kein Body — MUSS in Subklasse implementiert werden void schlafen() { // normal, kann geerbt werden System.out.println(name + " schläft"); } } class Hund extends Tier { @Override void machGeraeusch() { System.out.println("Wuff!"); // Pflicht: Compiler erzwingt es } } new Tier(); // FEHLER: kann nicht instantiiert werden, Tier ist abstract new Hund(); // OK

Teil 1·Erklärung

Erklärung

Vererbung & Polymorphie

Begriff

Was es bedeutet

Beispiel

Basisklasse / Superklasse / Parent

Die Klasse oben in der Hierarchie

Tier

Subklasse / Unterklasse / Child

Die Klasse, die erbt

Hund, Katze

extends (Java) / Klammern (Python)

Vererbungs-Syntax

class Hund extends Tier

Vererbung

Subklasse bekommt automatisch alle Felder + Methoden der Basisklasse

Hund hat name

Override

Subklasse ersetzt eine geerbte Methode mit eigener Version

Hund.machGeraeusch()

super (Java) / super() (Python)

Zugriff auf die Methode/Konstruktor der Basisklasse

super(name, alter)

is-a Beziehung

"Ein Hund ist ein Tier" — Faustregel für Vererbung

Hund is-a Tier ✓, Hund is-a Auto ✗

Vererbung & Polymorphie

Vererbung & Polymorphie

Das Problem

Die Begriffe

Code: extends (Java) und (Python)

Method-Dispatch: welche Methode wird aufgerufen?

Polymorphie: ein Typ, viele Formen

Override richtig: @Override und super.

super. innerhalb einer Override

abstract: Methoden ohne Body

Klausur-Tricks

Wo brauchst du Vererbung & Polymorphie?

Erklärung

Vererbung & Polymorphie

Variablen und Datentypen

Bedingungen

Schleifen

Vererbung & Polymorphie

Vererbung & Polymorphie

Das Problem

Die Begriffe

Code: extends (Java) und (Python)

Method-Dispatch: welche Methode wird aufgerufen?

Polymorphie: ein Typ, viele Formen

Override richtig: @Override und super.

super. innerhalb einer Override

abstract: Methoden ohne Body

Klausur-Tricks

Wo brauchst du Vererbung & Polymorphie?

Erklärung

Vererbung & Polymorphie

Variablen und Datentypen

Bedingungen

Schleifen

Das Problem

Die Begriffe

Code: extends (Java) und (Python)

Method-Dispatch: welche Methode wird aufgerufen?

Polymorphie: ein Typ, viele Formen

Override richtig: @Override und super.

super. innerhalb einer Override

abstract: Methoden ohne Body

Klausur-Tricks

Wo brauchst du Vererbung & Polymorphie?

Interaktiv

Hierarchie-Spielwiese

Quiz

Funktionen

Rekursion

Arrays und Listen