Summary  
This chapter covers the object-oriented composition pattern, where complex functionality is built by containing and delegating to independent component objects—using constructor and setter injection—to achieve 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 die Komposition Klassen, durch enthaltene Objekte zusammenzuarbeiten. 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 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 **Durchsickern 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 zahlreiche 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 voneinander abhängige interne Strukturen statt klarer Verträge nutzen.

Versteckte Kopplung

Welches häufige Risiko bei der Verwendung von Komposition kann das Design schwerer wartbar machen?

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 eine solide Grundlage, um zu verstehen, wie OOP Code organisiert und strukturiert.

Erkunden Sie, wie Klassen Funktionalitäten teilen und erweitern können. Sie lernen verschiedene Vererbungsmuster kennen, von einfachen Hierarchien bis hin zu Mehrfachvererbung und abstrakten Klassen, und erfahren, wie diese die Wiederverwendbarkeit und Skalierbarkeit von Code ermöglichen.

Erfahren Sie, wie Sie flexible Systeme durch die Kombination von Objekten erstellen. Anstatt sich ausschließlich auf Vererbung zu verlassen, zeigt Ihnen die Komposition, wie Sie Verhaltensweisen modular und anpassungsfähig zusammenstellen können.

Verstehen, wie verschiedene Objekte eine gemeinsame Schnittstelle teilen können, während sie sich unterschiedlich verhalten. Dieser Abschnitt zeigt, wie Methodenüberschreibung, Schnittstellen und Protokolle Ihren Code dynamischer und wiederverwendbarer machen.

Erfahren Sie, wie interne Daten geschützt und der Zugriff auf Klassenattribute kontrolliert werden kann. Sie werden private Attribute, Getter und Setter sowie Techniken zur Datenverbergung kennenlernen, die Ihre Klassen sicher und wartbar halten.

Kernprinzipien der Komposition