Summary  
Composition focuses on building complex systems by combining independent components through object containment and delegation instead of inheritance. It employs dependency injection (constructor and setter) to manage component lifecycles and promote modularity, flexibility, and testability.

General domain of usage  
E-commerce order processing

Komposition konzentriert sich darauf, komplexe Objekte durch die Kombination von einfacheren, unabhängigen Komponenten zu erstellen. Anstatt sich auf Vererbung zu verlassen, die starre Hierarchien erzeugt, ermöglicht Komposition Klassen die Zusammenarbeit durch enthaltene Objekte. Dieser Ansatz macht Systeme **flexibler**, **modularer** und **leichter wartbar**, da Komponenten ersetzt oder erweitert werden können, ohne die gesamte Struktur zu beeinträchtigen.

class Payment:
    def pay(self, amount):
        return f"Paid {amount}"


class Inventory:
    def reserve(self, item):
        return f"{item} reserved"


class Shipping:
    def ship(self, item):
        return f"{item} shipped"


class Order:
    def __init__(self, item, price, payment, inventory, shipping):
        self.item = item
        self.price = price
        self.payment = payment
        self.inventory = inventory
        self.shipping = shipping

    def process(self):
        return " | ".join([
            self.inventory.reserve(self.item),
            self.payment.pay(self.price),
            self.shipping.ship(self.item)
        ])


order = Order("Laptop", 1200, Payment(), Inventory(), Shipping())
print(order.process())

`Order` implementiert die Logik für Zahlung, Lagerbestand oder Versand nicht selbst.
Stattdessen **besitzt** es separate Objekte (`Payment`, `Inventory`, `Shipping`) und nutzt diese, um seine Aufgaben zu erfüllen.

Jede Komponente hat eine eigene Verantwortung, und `Order` koordiniert lediglich deren Zusammenarbeit.
Wenn Sie ändern möchten, wie Zahlung oder Versand funktioniert, können Sie die jeweilige Komponente austauschen, ohne die Klasse `Order` zu verändern.

Einige Fallstricke bei der Verwendung von Komposition sind das Erstellen von **Gottobjekten**, die zu viele Komponenten sammeln und schwer zu verwalten sind, das **Durchleiten von Komponenten-APIs** durch die äußere Klasse anstatt eine saubere Schnittstelle zu bewahren, sowie das Einführen von **versteckter Kopplung**, wenn Komponenten zu sehr von den internen Details anderer abhängen.


Ein God-Objekt versucht, zu viel zu übernehmen. Es enthält viele Komponenten und übernimmt viele Verantwortlichkeiten, was die Klasse schwer verständlich, testbar und wartbar macht.

God-Objekte

Dies tritt auf, wenn die äußere Klasse die internen Methoden oder Attribute ihrer Komponenten offenlegt. Anstatt eine eigene, klare Schnittstelle bereitzustellen, zwingt sie die Nutzer dazu, direkt mit internen Objekten zu interagieren.

Durchlässige Komponenten-APIs

Komponenten werden durch interne Details eng miteinander verbunden. Eine Änderung an einem Teil führt unerwartet zu Fehlern in einem anderen, da sie sich auf die interne Struktur des jeweils anderen anstatt auf klare Verträge verlassen.

Versteckte Kopplung

Was ist ein häufiges Risiko bei der Verwendung von Komposition, das das Design schwerer wartbar machen kann?

Erlernen Sie, wie man saubere, sichere und skalierbare Anwendungen mit objektorientierter Programmierung in Python entwickelt. Behandelt werden die Grundlagen von Klassen und Objekten sowie fortgeschrittene Konzepte wie Vererbung, Komposition, Polymorphismus und Kapselung. Mit klaren Erklärungen und praxisnahen Beispielen entwickeln Sie die Fähigkeit, Python-Programme zu entwerfen, die leistungsfähig, wartbar und für den realen Einsatz bereit sind.

Erlernen Sie die grundlegenden Bausteine der objektorientierten Programmierung in Python. Dieser Abschnitt behandelt Klassen, Objekte, Methoden und Variablen und vermittelt Ihnen eine solide Grundlage, um zu verstehen, wie OOP Code organisiert und strukturiert.

Kernprinzipien der Komposition