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

Compositie richt zich op het bouwen van complexe objecten door eenvoudigere, onafhankelijke componenten te combineren. In plaats van te vertrouwen op overerving, wat starre hiërarchieën creëert, maakt compositie het mogelijk dat klassen samenwerken via ingesloten objecten. Deze benadering maakt systemen **flexibeler**, **modulairder** en **makkelijker te onderhouden**, omdat componenten vervangen of uitgebreid kunnen worden zonder de gehele structuur te breken.

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` implementeert niet zelf de logica voor betaling, voorraad of verzending.
In plaats daarvan **heeft** het aparte objecten (`Payment`, `Inventory`, `Shipping`) en gebruikt deze om het werk uit te voeren.

Elke component heeft één verantwoordelijkheid en `Order` coördineert deze alleen.
Als je wilt veranderen hoe betaling of verzending werkt, kun je de component vervangen zonder de `Order`-klasse aan te passen.


Enkele valkuilen bij het gebruik van compositie zijn het creëren van **god-objecten** die te veel componenten verzamelen en moeilijk te beheren worden, **het lekken van component-API's** via de buitenste klasse in plaats van een duidelijke interface te behouden, en het introduceren van **verborgen koppeling** wanneer componenten te veel afhankelijk zijn van elkaars interne details.


Een god-object probeert te veel te doen. Het bevat veel componenten en behandelt veel verantwoordelijkheden, waardoor de klasse moeilijk te begrijpen, testen en onderhouden is.

God-objecten

Dit gebeurt wanneer de buitenste klasse de interne methoden of attributen van zijn componenten blootstelt. In plaats van een eigen duidelijke interface te bieden, dwingt het gebruikers om direct met interne objecten te werken.

Lekken van component-API's

Componenten raken sterk met elkaar verbonden via interne details. Het wijzigen van één onderdeel veroorzaakt onverwacht problemen bij een ander, omdat ze afhankelijk zijn van elkaars interne structuur in plaats van duidelijke contracten.

Verborgen koppeling

Wat is een veelvoorkomend risico bij het gebruik van compositie dat het ontwerp moeilijker te onderhouden kan maken?

Leer hoe je schone, veilige en schaalbare applicaties bouwt met objectgeoriënteerd programmeren in Python. Behandel de basisprincipes van klassen en objecten, en ga vervolgens in op geavanceerde concepten zoals overerving, compositie, polymorfisme en encapsulatie. Met duidelijke uitleg en praktische voorbeelden ontwikkel je het vermogen om Python-programma's te ontwerpen die krachtig, onderhoudbaar en klaar zijn voor gebruik in de praktijk.

Leer de kernbouwstenen van objectgeoriënteerd programmeren in Python. Deze sectie behandelt klassen, objecten, methoden en variabelen, en biedt een solide basis om te begrijpen hoe OOP code organiseert en structureert.

Ontdek hoe klassen functionaliteit kunnen delen en uitbreiden. U leert verschillende overervingspatronen, van eenvoudige hiërarchieën tot meervoudige overerving en abstracte klassen, en ziet hoe deze codehergebruik en schaalbaarheid mogelijk maken.

Ontdek hoe u flexibele systemen kunt bouwen door objecten te combineren. In plaats van uitsluitend te vertrouwen op overerving, ziet u hoe compositie het mogelijk maakt om gedragingen op een modulaire en aanpasbare manier samen te stellen.

Begrijpen hoe verschillende objecten een gemeenschappelijke interface kunnen delen terwijl ze zich op hun eigen manier gedragen. Deze sectie laat zien hoe methode-overschrijving, interfaces en protocollen uw code dynamischer en herbruikbaarder maken.

Leer hoe interne gegevens kunnen worden beschermd en de toegang tot klasse-attributen kan worden beheerst. U verkent private attributen, getters en setters, en technieken voor het verbergen van gegevens die uw klassen veilig en onderhoudbaar houden.

Kernprincipes van compositie