Summary  
This chapter covers composition in object-oriented programming, where a class contains instances of other classes (has-a relationships) to assemble complex objects with loose coupling and modular, swappable components instead of using inheritance.

General domain of usage  
Object-oriented software design

**Compositie** vertegenwoordigt een **heeft-een-relatie**, waarbij een klasse een instantie van een andere klasse bevat in plaats van ervan te erven. Bijvoorbeeld, een **Auto heeft een Motor**. Dit verschilt van **overerving**, dat een **is-een-relatie** modelleert, zoals een **Vrachtwagen is een Voertuig**.

class Engine:
    def start(self):
        return "Engine started"

class Car:
    def __init__(self, brand, engine):
        self.brand = brand
        self.engine = engine   # Car HAS an Engine

    def drive(self):
        return f"{self.brand}: {self.engine.start()}"


engine = Engine()
car = Car("Toyota", engine)

print(car.drive())

`Car` erft niet van `Engine`. In plaats daarvan **bevat** het een `Engine`-object en gebruikt het dit om zijn taken uit te voeren. Dit toont een **heeft-een** relatie, geen **is-een**, waardoor het ontwerp flexibeler en later eenvoudiger aan te passen is.

Samenstelling gebruiken wanneer **flexibele onderdelen**, **duidelijke grenzen** en **runtime-vervanging** van gedrag nodig zijn. **Erfelijkheid verkiezen** wanneer een **echte is-a** hiërarchie duidelijk en stabiel is.


Opmerking

Wat is het belangrijkste voordeel van het gebruik van samenstelling?

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.

Introductie tot Compositie