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

La composition consiste à construire des objets complexes en combinant des composants plus simples et indépendants. Plutôt que de s'appuyer sur l'héritage, qui crée des hiérarchies rigides, la composition permet aux classes de collaborer via des objets contenus. Cette approche rend les systèmes plus **flexibles**, **modulaires** et **faciles à maintenir**, car les composants peuvent être remplacés ou étendus sans perturber l'ensemble de la structure.

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` n'implémente pas lui-même la logique de paiement, de gestion des stocks ou d'expédition.
Au lieu de cela, il **possède** des objets séparés (`Payment`, `Inventory`, `Shipping`) et les utilise pour accomplir son travail.

Chaque composant a une responsabilité unique, et `Order` ne fait que les coordonner.
Si vous souhaitez modifier la façon dont le paiement ou l'expédition fonctionnent, vous pouvez remplacer le composant sans modifier la classe `Order`.

Quelques écueils à éviter lors de l'utilisation de la composition : créer des **objets dieux** qui accumulent trop de composants et deviennent difficiles à gérer, **divulguer les API des composants** à travers la classe externe au lieu de maintenir une interface propre, et introduire un **couplage caché** lorsque les composants dépendent trop des détails internes des autres.


Un objet dieu essaie d’en faire trop. Il contient de nombreux composants et gère de nombreuses responsabilités, ce qui rend la classe difficile à comprendre, à tester et à maintenir.

Objets dieu

Cela se produit lorsque la classe externe expose les méthodes ou attributs internes de ses composants. Au lieu de fournir sa propre interface claire, elle oblige les utilisateurs à interagir directement avec les objets internes.

Fuite des API de composants

Les composants deviennent fortement liés par des détails internes. Modifier une partie casse de façon inattendue une autre, car ils dépendent de la structure interne de chacun au lieu de contrats clairs.

Couplage caché

Quel est un risque courant lors de l’utilisation de la composition qui peut rendre la conception plus difficile à maintenir ?

Apprenez à créer des applications propres, sécurisées et évolutives avec la programmation orientée objet en Python. Couvrez les fondamentaux des classes et des objets, puis passez à des concepts avancés tels que l'héritage, la composition, le polymorphisme et l'encapsulation. Grâce à des explications claires et des exemples pratiques, vous développerez la capacité de concevoir des programmes Python puissants, maintenables et prêts pour une utilisation réelle.

Découvrez les éléments fondamentaux de la programmation orientée objet en Python. Cette section aborde les classes, les objets, les méthodes et les variables, vous offrant une base solide pour comprendre comment la POO organise et structure le code.

Découvrez comment les classes peuvent partager et étendre des fonctionnalités. Vous étudierez différents modèles d'héritage, des hiérarchies simples à l'héritage multiple et aux classes abstraites, et verrez comment ils permettent la réutilisation du code et l'évolutivité.

Découvrez comment créer des systèmes flexibles en combinant des objets. Plutôt que de s'appuyer uniquement sur l'héritage, vous verrez comment la composition permet d'assembler des comportements de manière modulaire et adaptable.

Comprendre comment différents objets peuvent partager une interface commune tout en ayant des comportements propres. Cette section montre comment la redéfinition de méthodes, les interfaces et les protocoles rendent le code plus dynamique et réutilisable.

Découvrez comment protéger les données internes et contrôler l'accès aux attributs de classe. Vous étudierez les attributs privés, les accesseurs et mutateurs, ainsi que les techniques de masquage des données qui assurent la sécurité et la maintenabilité de vos classes.

Core Principles of Composition