Python Komposition vs. Vererbung: Wann was nutzen?

Stell dir vor, du designst dein erstes größeres Python-Projekt. Du baust eine App zur Verwaltung von Fahrzeugen. Dein erster Reflex? Eine Basisklasse `Fahrzeug` schreiben, von der alles andere erbt. Drei Wochen später sollen plötzlich auch Boote und Flugzeuge verwaltet werden. Jetzt passt deine Struktur nicht mehr, denn Flugzeuge haben weder Räder noch eine Straßenzulassung. Genau hier zeigt sich das klassische Dilemma: Python Komposition Vererbung - wann nutzt du welchen Ansatz?

In der objektorientierten Programmierung (OOP) strukturieren wir Code durch Klassen und Objekte. Dabei wirst du immer wieder vor der Entscheidung stehen: Erbt eine Klasse von einer anderen (Vererbung) oder baut sie sich aus anderen Objekten zusammen (Komposition)?

Was ist Vererbung in Python?

Vererbung (Inheritance) ist ein Mechanismus, bei dem eine neue Klasse Eigenschaften und Methoden von einer bestehenden Klasse übernimmt. Du modellierst damit eine "ist-ein"-Beziehung (is-a). Ein Auto *ist ein* Fahrzeug.

Die neue Klasse (Kindklasse oder Subclass) übernimmt die Funktionalität der bestehenden Klasse (Elternklasse oder Superclass). Sie kann diese erweitern oder anpassen.

class Fahrzeug:
    def __init__(self, marke, baujahr):
        self.marke = marke
        self.baujahr = baujahr

    def starten(self):
        return f"Das {self.marke} startet den Motor."


class Auto(Fahrzeug):
    def __init__(self, marke, baujahr, anzahl_tueren):
        super().__init__(marke, baujahr)
        self.anzahl_tueren = anzahl_tueren

    def hupen(self):
        return "Hup! Hup!"


mein_auto = Auto("Volkswagen", 2023, 4)
print(mein_auto.starten())  # Geerbte Methode
print(mein_auto.hupen())  # Eigene Methode

Das Schlüsselwort `super()` ruft dabei den Konstruktor der Elternklasse auf.

Merke: Vererbung modelliert eine "ist-ein"-Beziehung. Nutze sie nur, wenn die Kindklasse wirklich ein spezifischeres Exemplar der Elternklasse ist.

Weitere Details zur Vererbung findest du in der offiziellen Python-Dokumentation zu Klassen.

Was ist Komposition in Python?

Komposition (Composition) bedeutet, dass eine Klasse andere Objekte als Attribute enthält und deren Funktionalität nutzt. Statt zu erben, "besitzt" die Klasse andere Objekte. Das modelliert eine "hat-ein"-Beziehung (has-a).

Stell dir das wie einen Computer vor: Er *hat* eine Festplatte, *hat* einen Prozessor und *hat* Arbeitsspeicher. Aber er *ist* keine Festplatte. Genau so baust du bei der Komposition komplexe Objekte aus einfacheren, eigenständigen Komponenten zusammen.

class Motor:
    def __init__(self, leistung_ps):
        self.leistung_ps = leistung_ps

    def starten(self):
        return f"Motor mit {self.leistung_ps} PS laeuft."


class Auto:
    def __init__(self, marke, motor):
        self.marke = marke
        self.motor = motor  # Auto HAT einen Motor

    def starten(self):
        return f"{self.marke}: {self.motor.starten()}"


mein_motor = Motor(150)
mein_auto = Auto("Volkswagen", mein_motor)
print(mein_auto.starten())

Der große Vorteil hierbei: Du kannst den Motor zur Laufzeit (während das Programm läuft) flexuell austauschen.

Merke: Komposition bedeutet "hat-ein". Ein Objekt besteht aus anderen Objekten, die es bei der Erstellung übergeben bekommt oder selbst erzeugt.

Python Komposition vs. Vererbung: Der direkte Vergleich

Wann ist nun welcher Ansatz besser? Um das zu entscheiden, schauen wir uns die Eigenschaften beider Konzepte direkt gegenüber an:

Merke: Komposition ist flexibler als Vererbung, weil du Objekte zur Laufzeit austauschen kannst. Bei Vererbung ist die Hierarchie fest in Stein gemeißelt.

Wann nutzt du Komposition, wann Vererbung?

Du nutzt Vererbung, wenn eine echte Hierarchie existiert und die Kindklasse die Elternklasse vollständig ersetzen kann. Das nennt man das Liskov-Substitutionsprinzip. Ein Objekt der Kindklasse muss überall fehlerfrei funktionieren, wo ein Objekt der Elternklasse erwartet wird.

Typische Fälle für Vererbung sind:

• `Hund` und `Katze` erben von `Tier`

• `Kreis` und `Rechteck` erben von `Form`

• `Admin` und `Nutzer` erben von `Benutzer`

Du nutzt Komposition, wenn Klassen zwar bestimmte Fähigkeiten brauchen, aber keine echte "ist-ein"-Beziehung besteht. Auch wenn du Verhalten aus mehreren Quellen kombinieren willst, ist dies der bessere Weg.

Typische Fälle für Komposition:

• Ein `Auto` hat einen `Motor`

• Ein `Spieler` hat ein `Inventar`

• Ein `Mitarbeiter` hat eine `Adresse`

In der Praxis wird Komposition oft bevorzugt. Warum? Weil Vererbungshierarchien extrem starr sind. Sobald eine Klasse von einer anderen erbt, ist diese Verbindung fest "eingebaut". Möchtest du das Verhalten später ändern, musst du die ganze Hierarchie umstrukturieren. Bei der Komposition tauschst du einfach das eingebettete Objekt aus.

Empfehlung: Wenn du unsicher bist, wähle immer Komposition. Du kannst später immer noch auf Vererbung wechseln - umgekehrt ist das ein massives Refactoring.

Wie sieht das in der Praxis aus? Ein Rollenspiel-Beispiel

Stell dir vor, du entwickelst ein kleines Rollenspiel. Ein Charakter soll verschiedene Fähigkeiten haben: angreifen, heilen und sich verteidigen. Mit Komposition baust du das flexibel auf.

class Waffe:
    def __init__(self, name, schaden):
        self.name = name
        self.schaden = schaden

    def angreifen(self):
        return f"Greift an mit {self.name} fuer {self.schaden} Schaden."


class Heilung:
    def __init__(self, heilwert):
        self.heilwert = heilwert

    def heilen(self):
        return f"Heilt sich um {self.heilwert} Lebenspunkte."


class Schild:
    def __init__(self, blockwert):
        self.blockwert = blockwert

    def verteidigen(self):
        return f"Blockt {self.blockwert} Schaden."


class Charakter:
    def __init__(self, name, waffe=None, heilung=None, schild=None):
        self.name = name
        self.waffe = waffe
        self.heilung = heilung
        self.schild = schild

    def angreifen(self):
        if self.waffe:
            return f"{self.name}: {self.waffe.angreifen()}"
        return f"{self.name} hat keine Waffe."

    def heilen(self):
        if self.heilung:
            return f"{self.name}: {self.heilung.heilen()}"
        return f"{self.name} kann nicht heilen."

    def verteidigen(self):
        if self.schild:
            return f"{self.name}: {self.schild.verteidigen()}"
        return f"{self.name} hat keinen Schild."


# Krieger mit Schwert und Schild
schwert = Waffe("Feuerschwert", 50)
schild = Schild(20)
krieger = Charakter("Thorin", waffe=schwert, schild=schild)

# Magier mit Heilung
heilzauber = Heilung(30)
magier = Charakter("Gandalf", heilung=heilzauber)

print(krieger.angreifen())
print(krieger.verteidigen())
print(magier.heilen())
print(krieger.heilen())

Hättest du das mit Vererbung gelöst, bräuchtest du schnell Klassen wie `Krieger(Waffe, Schild)`. Das funktioniert bei drei Fähigkeiten vielleicht noch. Aber bei zehn? Dann wird die Hierarchie komplett unübersichtlich. Mit Komposition gibst du jedem Charakter genau die Fähigkeiten-Objekte, die er wirklich braucht.

Welche typischen Fehler solltest du bei OOP-Strukturen vermeiden?

Gerade zu Beginn der Programmierlaufbahn passieren oft ähnliche Fehler.

Fehler 1: Vererbung für alles nutzen

Viele Einsteiger modelieren alles über Vererbung. Eine Klasse `Mitarbeiter` erbt von `Person`, `Kunde` erbt ebenfalls von `Person`. Das wirkt anfangs logisch. Aber dann soll ein `Mitarbeiter` plötzlich auch als `Kunde` einkaufen können. Wer erbt jetzt von wem? Die Hierarchie bricht zusammen.

Lösung: Nutze Komposition. Ein `Mitarbeiter` *hat* eine `Rolle` (z.B. Mitarbeiter und Kunde gleichzeitig).

Fehler 2: Mehrfachvererbung überstrapazieren

Python unterstützt Mehrfachvererbung (eine Klasse erbt von mehreren Eltern). Das führt oft zum Diamond Problem: Zwei Elternklassen erben von derselben Großelternklasse, und die Kindklasse erbt von beiden. Welche Methode wird nun aufgerufen?

# FALSCH: Unuebersichtliche Mehrfachvererbung
class Fliegen:
    def bewegen(self):
        return "Fliegt"


class Schwimmen:
    def bewegen(self):
        return "Schwimmt"


class Ente(Fliegen, Schwimmen):
    pass


# Welche bewegen()-Methode wird aufgerufen?

Lösung: Bei komplexen Fähigkeiten nutzt du besser Komposition statt Mehrfachvererbung.

Fehler 3: Elternklassen-Interna ausnutzen

Wenn eine Kindklasse auf "protected" oder private Attribute der Elternklasse zugreift, entsteht eine sehr enge Kopplung. Ändert sich ein Detail in der Elternklasse, bricht die Kindklasse sofort. Das widerspricht dem Prinzip der Kapselung.

FAQ

Was ist der Unterschied zwischen Komposition und Vererbung?

Vererbung modelliert eine "ist-ein"-Beziehung (ein Auto ist ein Fahrzeug) und erbt Code direkt. Komposition modelliert eine "hat-ein"-Beziehung (ein Auto hat einen Motor) und bettet eigenständige Objekte ein.

Wann sollte ich Komposition statt Vererbung nutzen?

Nutze Komposition, wenn keine echte Hierarchie besteht, wenn du Verhalten flexibel kombinieren willst oder wenn Vererbung zu starrer Kopplung führen würde. Die Faustregel lautet: Im Zweifel immer Komposition.

Was ist das Diamond Problem in Python?

Das Diamond Problem entsteht bei Mehrfachvererbung, wenn zwei Elternklassen von derselben Basisklasse erben. Python löst das technisch über die MRO (Method Resolution Order). Architektonisch vermeidest du das Problem besser durch Komposition. Details zur MRO bietet die Python-Dokumentation.

Kann ich Vererbung und Komposition gleichzeitig nutzen?

Ja, absolut. In der Praxis kombinierst du beide Konzepte. Eine Klasse kann von einer Basisklasse erben und gleichzeitig andere Objekte einbetten. Ein Beispiel: `Klassensprecher(Schueler)` erbt von `Schueler` und hat zusätzlich ein `Wahlkomitee`-Objekt.

Fazit

Beim Thema Python Komposition Vererbung gibt es keine absoluten Feinde, sondern nur Werkzeuge für unterschiedliche Aufgaben. Vererbung eignet sich für echte Hierarchien mit klaren "ist-ein"-Beziehungen. Komposition ist deutlich flexibler, lockerer gekoppelt und lässt sich in Tests leichter simulieren.

Die goldene Regel der objektorientierten Programmierung lautet: Wenn unsicher, wähle Komposition. Du kannst später immer noch Vererbung ergänzen.

Brauchst du Hilfe bei OOP-Konzepten, Python-Projekten oder der Prüfungsvorbereitung? Bei study-it.education findest du erfahrene Nachhilfelehrer, die dir genau dort helfen, wo du festhängst. Egal, ob du Azubi, Student oder Berufseinsteiger bist - schau vorbei und buche deine erste Session!