Wat is een decorator?

De decorator is een structureel ontwerppatroon dat het mogelijk maakt om dynamisch nieuwe functionaliteit aan een object toe te voegen, zonder de structuur ervan te wijzigen. Het omhult het object, biedt dezelfde interface als het omhulde object, en voegt gedrag toe of wijzigt het.

Belangrijke elementen:

• Component: Interface of abstracte klasse die de gemeenschappelijke functionaliteit definieert voor omhulde objecten en decorateurs.
• Concrete Component: Implementatie van de component, het basiselement waaraan functionaliteit wordt toegevoegd.
• Decorator: Abstracte klasse die de interface van de component implementeert en een verwijzing naar een componentobject bevat.
• Concrete Decorator: Implementatie van de decorator die specifieke functionaliteit toevoegt vóór of na het aanroepen van de methode van het omhulde object.

Voorbeeld in Python:

# Component
class Coffee:
    def get_cost(self):
        return 5 # Basisprijs koffie
    
    def get_description(self):
        return "Eenvoudige koffie"

# Concrete component
class SimpleCoffee(Coffee):
    pass

# Decorator
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()

# Concrete decorator
class MilkDecorator(CoffeeDecorator):
    def get_cost(self):
        return self._coffee.get_cost() + 2 # Voeg de kosten van melk toe

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

# Gebruik
# simple_coffee = SimpleCoffee()
# print(f"Kosten: {simple_coffee.get_cost()}, Beschrijving: {simple_coffee.get_description()}")

# koffie_met_melk = MilkDecorator(simple_coffee)
# print(f"Kosten: {koffie_met_melk.get_cost()}, Beschrijving: {koffie_met_melk.get_description()}")

Voordelen:

• Flexibiliteit: Functionaliteit kan tijdens de uitvoering worden toegevoegd.
• Vermijden van subklassen: Het voorkomt het creëren van veel subklassen voor elke gedragcombinatie.
• Verantwoordelijkheden scheiden: Elke toevoeging van gedrag wordt in een aparte klasse gedaan.

Nadelen:

• Kan het aantal klassen vergroten.
• Debuggen kan moeilijker worden door de keten van omhullingen.