Après cette leçon, tu seras capable de :

• Distinguer une relation d'héritage est-un d'une relation de composition a-un.
• Construire une classe qui reçoit et stocke un objet collaborateur.
• Déléguer le travail à ce collaborateur via une méthode commune.
• Remplacer des collaborateurs sans modifier la classe qui les utilise.

L'héritage indique qu'une classe est une sorte d' autre classe (class PremiumAccount(Account)). La composition indique qu'un objet possède un autre objet pour l'aider à accomplir son travail (Notifier possède un Formatter). Les deux modèles sont utiles, mais l'héritage doit représenter une véritable relation de type plutôt qu'un raccourci pour réutiliser du code.

Avec la composition, le constructeur de l'objet externe reçoit un collaborateur et le stocke. Il délègue ensuite le travail : self.formatter.render(message). Fournir le collaborateur depuis l'extérieur (injection par constructeur) facilite le changement de comportement et le test de la classe externe sans avoir à la modifier.

Ne crée pas automatiquement un collaborateur de remplacement dans le constructeur lorsque l'appelant en a déjà fourni un ; cela ignorerait le comportement choisi. La composition évite également de grandes chaînes d'héritage lorsque le seul but est de combiner des responsabilités distinctes.

1. Un service possède un formateur

class Formatter:
    def render(self, value):
        return value.upper()

class Service:
    def __init__(self, formatter):
        self.formatter = formatter

    def output(self, value):
        return self.formatter.render(value)

service = Service(Formatter())
print(service.output("ready"))

Sortie :

READY

2. Remplacer un collaborateur

Deux formateurs partagent la même méthode mais produisent des résultats différents.

class PlainFormatter:
    def render(self, message):
        return message

class BracketFormatter:
    def render(self, message):
        return f"[{message}]"

class Reporter:
    def __init__(self, formatter):
        self.formatter = formatter

    def report(self, message):
        return self.formatter.render(message)

print(Reporter(PlainFormatter()).report("ok"))
print(Reporter(BracketFormatter()).report("ok"))

Sortie :

ok
[ok]

3. Comparer avec une relation est-un

L'héritage est approprié lorsque l'enfant est réellement un type spécialisé de son parent.

class Storage:
    def kind(self):
        return "storage"

class CloudStorage(Storage):
    def kind(self):
        return "cloud storage"

print(CloudStorage().kind())

Sortie :

cloud storage

Un stockage cloud est un type de stockage ; un service a un formateur.

4. Composer une politique et déléguer une décision

class RetryPolicy:
    def can_retry(self, attempt):
        return attempt < 3

class Worker:
    def __init__(self, policy):
        self.policy = policy

    def should_retry(self, attempt):
        return self.policy.can_retry(attempt)

print(Worker(RetryPolicy()).should_retry(2))

Sortie :

True

1. Hériter d'un collaborateur alors que la relation est « a un ».
2. Ignorer un collaborateur injecté et en créer un nouveau codé en dur.
3. Oublier de déléguer via l'instance stockée (self.formatter).
4. Lier la classe externe à une seule implémentation alors que plusieurs collaborateurs compatibles devraient fonctionner.