Polymorphie & Vererbung

Vererbung & Methoden überschreiben

Was ist Vererbung?

Vererbung (engl. Inheritance) bedeutet:
Eine Klasse (die Unterklasse oder Subklasse) erbt Eigenschaften und Methoden von einer anderen Klasse (der Oberklasse oder Superklasse).

Das spart Code und sorgt dafür, dass Klassen sich ähnlich verhalten, wenn sie etwas gemeinsam haben.

Beispiel:

class Tier {
    void macheGeräusch() {
        System.out.println("Ein Geräusch");
    }
}

class Katze extends Tier {
    @Override
    void macheGeräusch() {
        System.out.println("Miau");
    }
}

Erklärung:

• Tier ist die Oberklasse.
• Katze ist die Unterklasse – sie erbt alles von Tier.
• Die Methode macheGeräusch() wird in Katze überschrieben (Fachbegriff: Methodenüberschreibung / Override).

Was passiert beim Methoden überschreiben?

Wenn die Unterklasse eine Methode neu definiert, die schon in der Oberklasse existiert, spricht man von Überschreiben (engl. Overriding).

Das Schlüsselwort @Override zeigt dem Compiler:
„Ich will hier bewusst eine Methode der Oberklasse ersetzen.“

Verwendung:

Katze k = new Katze();
k.macheGeräusch(); // Ausgabe: Miau

Vorteile der Vererbung:

1. Code-Wiederverwendung
   → Gemeinsame Funktionen kommen in die Oberklasse.
2. Polymorphismus
   → Du kannst mit einem Oberklassen-Typ arbeiten, aber unterschiedliche Unterklassen verwenden:
3. Erweiterbarkeit
   → Du kannst leicht neue Klassen hinzufügen, ohne bestehenden Code zu ändern.

Klar! Ich erkläre dir Polymorphie nochmal richtig verständlich – mit anschaulichen Beispielen, passenden Fachbegriffen und einer einfachen Erklärung, warum das wichtig ist:

Polymorphie (Vielgestaltigkeit)

Was bedeutet Polymorphie?

Polymorphie kommt aus dem Griechischen und bedeutet "Vielgestaltigkeit".

In der Programmierung heißt das:

Ein Objekt kann sich unterschiedlich verhalten, obwohl es vom gleichen Typ ist.

Oder einfacher gesagt:

Eine Methode sieht gleich aus, macht aber je nach Objekt etwas anderes.

Beispiel mit Tieren:

class Tier {
    void macheGeräusch() {
        System.out.println("Ein Geräusch");
    }
}

class Katze extends Tier {
    @Override
    void macheGeräusch() {
        System.out.println("Miau");
    }
}

class Hund extends Tier {
    @Override
    void macheGeräusch() {
        System.out.println("Wuff");
    }
}

Polymorphes Verhalten:

Tier t1 = new Katze();
Tier t2 = new Hund();

t1.macheGeräusch(); // Ausgabe: Miau
t2.macheGeräusch(); // Ausgabe: Wuff

Warum ist das wichtig?

1. Vereinfachung des Codes
   Du kannst mit einer gemeinsamen Oberklasse arbeiten, ohne jede Unterklasse einzeln behandeln zu müssen.
2. Erweiterbarkeit
   Du kannst neue Unterklassen hinzufügen, ohne bestehenden Code zu ändern – das spart Zeit und vermeidet Fehler.
3. Flexibilität durch Oberklassen-Referenzen
   Du kannst Listen, Arrays oder Methoden schreiben, die mit der Oberklasse arbeiten – und trotzdem passendes Verhalten bekommen.

Beispiel mit einer Methode:

void spieleMitTier(Tier t) {
    t.macheGeräusch();
}

spieleMitTier(new Katze()); // Ausgabe: Miau
spieleMitTier(new Hund());  // Ausgabe: Wuff