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

La composition consiste à construire des objets complexes en combinant des composants plus simples et indépendants. Au lieu 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.
À la place, il **possède** des objets distincts (`Payment`, `Inventory`, `Shipping`) et les utilise pour accomplir son travail.

Chaque composant a une responsabilité unique, et `Order` se contente de les coordonner.
Si vous souhaitez modifier le fonctionnement du paiement ou de l'expédition, il suffit de 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 des **couplages cachés** lorsque les composants dépendent excessivement 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 dieux

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 des 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 adaptés à 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.

Principes Fondamentaux de la Composition