Vererbung ist eines der Kernkonzepte der Objektorientierten Programmierung (OOP).
Sie erlaubt einer Klasse (dem Kind oder Unterklasse) die Attribute und Methoden einer anderen Klasse (dem Elternteil oder Oberklasse) zu erben.

Das bedeutet, dass du allgemeines Verhalten und Daten in einer Basisklasse definieren kannst und dann spezialisiertere Klassen erstellst, die diese Funktionalität wiederverwenden und anpassen — ohne denselben Code neu schreiben zu müssen.

Grundsyntax der Vererbung

In Python wird Vererbung umgesetzt, indem der Name der Elternklasse in Klammern nach dem Namen der Kindklasse angegeben wird.

class ParentClass:
    # Attribute und Methoden der Elternklasse

class ChildClass(ParentClass):
    # Attribute und Methoden der Kindklasse

Wenn eine Kindklasse von einer Elternklasse erbt, erhält sie:

• Alle Attribute des Elternteils (Variablen, die mit dem Objekt verbunden sind)
• Alle Methoden des Elternteils (Funktionen, die mit dem Objekt verbunden sind)
• Jeden Konstruktor (__init__), den die Elternklasse hat

Beispiel: Tiere und Geräusche

Bringen wir Vererbung mit etwas, das jeder kennt, zum Leben — Tieren.
Wir starten mit einer allgemeinen Animal-Klasse, die definiert, was alle Tiere gemeinsam haben, und erstellen dann spezifische Tierarten (Dog und Cat), die diese Eigenschaften teilen, aber unterschiedliche Geräusche machen.

Hier ist die Basisklasse:

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sound(self):
        pass  # Wir lassen jedes konkrete Tier seinen eigenen Ton bestimmen

Die Animal-Klasse hat:

• Eine __init__-Methode, die den name und age für jedes Tier setzt.
• Eine sound()-Methode, die noch nichts tut (pass ist nur ein Platzhalter). Diese ersetzen wir in jedem Tier mit dem jeweiligen Geräusch der Art.

Jetzt erstellen wir zwei spezifische Tierklassen:

class Dog(Animal):
    def sound(self):
        print("Woof woof!")

class Cat(Animal):
    def sound(self):
        print("Meow!")

Das passiert hier:

• Sowohl Dog als auch Cat erben von Animal, wodurch sie automatisch die Attribute name und age bekommen, ohne dass wir den Code wiederholen müssen.
• Jede Klasse überschreibt die sound()-Methode, um ihr eigenes Geräusch zu machen.

Objekte erstellen und verwenden

dog = Dog("Rex", 2)
cat = Cat("Mimi", 3)

print(dog.name)  # Rex
dog.sound()      # Woof woof!

print(cat.name)  # Mimi
cat.sound()      # Meow!

Wenn wir Dog("Rex", 2) erstellen, passiert Schritt für Schritt:

1. Python ruft die __init__-Methode von Animal auf (weil Dog keine eigene hat).
2. Die übergebenen Werte für name und age werden im neuen Objekt gespeichert.
3. Beim Aufruf von dog.sound() sucht Python zuerst nach einer sound()-Methode in Dog. Es findet dort die selbst geschriebene Methode und führt sie aus — dabei wird "Woof woof!" ausgegeben.

Dasselbe gilt für Cat, das seine eigene sound()-Methode findet und ausführt.

Dieses Beispiel zeigt die Magie der Vererbung:

• Wir schreiben die gemeinsame Einrichtung (__init__) nur einmal, in der Animal-Klasse.
• Jede Unterklasse (Dog, Cat) behält die gemeinsamen Eigenschaften und fügt ihr eigenes Verhalten hinzu.
• Das Ergebnis ist weniger sich wiederholender Code, besser organisierte Logik und eine einfachere Verwaltung verwandter Objekte.

3. Wie das funktioniert

• Gemeinsame Struktur: Die __init__-Methode von Animal wird ausgeführt, wenn du ein Dog- oder Cat-Objekt erzeugst, weil sie automatisch geerbt wird.
• Methodenüberschreibung: Sowohl Dog als auch Cat haben eigene sound()-Methoden, die die Platzhalter-Methode in Animal ersetzen (überschreiben). Wenn du sound() auf einem Dog aufrufst, verwendet Python die in Dog definierte Methode, nicht die in Animal.

TIP: Wenn eine Unterklasse eine Methode nicht überschreibt, wird automatisch die Methode der Elternklasse verwendet.

Warum Vererbung nutzen?

Vererbung ermöglicht es dir:

• Code-Duplikationen zu vermeiden, indem gemeinsame Logik in eine einzige Basisklasse gelegt wird.
• Deinen Code modularer und lesbarer zu machen.
• Spezialisierte Klassen auf Grundlage einer allgemeinen Vorlage zu erstellen.

Denkweise bei Vererbung:

• Animal → allgemeine Vorlage mit name, age und einer sound()-Methode.
• Dog → eine spezifische Tierart mit eigenem, einzigartigem Geräusch.
• Cat → eine weitere spezifische Tierart mit anderem Geräusch.

Zusammenfassung

Vererbung ist ein mächtiges Werkzeug in der OOP, um eine Klassenhierarchie zu erstellen, die von allgemeinen Konzepten zu spezialisierteren führt.

In Python setzt du sie um, indem du:

1. Eine Elternklasse mit gemeinsamen Attributen und Methoden schreibst.
2. Unterklassen erstellst, die den Namen der Elternklasse in Klammern angeben.
3. Methoden in den Unterklassen je nach Bedarf hinzufügst oder überschreibst.

Im nächsten Unterricht bauen wir auf diesem Konzept auf und erkunden super() — eine Möglichkeit für Unterklassen, das Verhalten ihrer Elternklassen aufzurufen und zu erweitern.