Qu'est-ce qu'un décorateur (Decorator) ?

Le décorateur est un patron de conception structurel qui permet d’ajouter dynamiquement de nouvelles fonctionnalités à un objet, sans en modifier la structure. Il enveloppe l’objet, en fournissant la même interface que l’objet enveloppé, tout en ajoutant ou modifiant son comportement.

Éléments principaux:

• Composant (Component): Interface ou classe abstraite définissant la fonctionnalité commune pour les objets enveloppés et les décorateurs.
• Composant Concret (Concrete Component): Implémentation du composant, objet de base auquel une fonctionnalité est ajoutée.
• Décorateur (Decorator): Classe abstraite qui implémente l’interface du composant et contient une référence à un objet composant.
• Décorateur Concret (Concrete Decorator): Implémentation du décorateur qui ajoute une fonctionnalité spécifique avant ou après l’appel de la méthode de l’objet enveloppé.

Exemple en Python:

# Composant
class Coffee:
    def get_cost(self):
        return 5 # Coût de base du café
    
    def get_description(self):
        return "Café simple"

# Composant Concret
class SimpleCoffee(Coffee):
    pass

# Décorateur
class CoffeeDecorator(Coffee):
    def __init__(self, coffee):
        self._coffee = coffee

    def get_cost(self):
        return self._coffee.get_cost()

    def get_description(self):
        return self._coffee.get_description()

# Décorateur Concret
class MilkDecorator(CoffeeDecorator):
    def get_cost(self):
        return self._coffee.get_cost() + 2 # Ajoute le coût du lait

    def get_description(self):
        return self._coffee.get_description() + ", Lait"

# Utilisation
# simple_coffee = SimpleCoffee()
# print(f"Coût: {simple_coffee.get_cost()}, Description: {simple_coffee.get_description()}")

# coffee_with_milk = MilkDecorator(simple_coffee)
# print(f"Coût: {coffee_with_milk.get_cost()}, Description: {coffee_with_milk.get_description()}")

Avantages:

• Flexibilité: La fonctionnalité est ajoutée au moment de l’exécution.
• Évitement des sous-classes: Permet d’éviter la création de nombreuses sous-classes pour chaque combinaison de comportements.
• Séparation des responsabilités: Chaque ajout de comportement est isolé dans une classe distincte.

Inconvénients:

• Peut augmenter le nombre de classes.
• Le débogage peut devenir plus complexe en raison de la chaîne d’enveloppes.