What is the Decorator Pattern?
The Decorator Pattern is a structural design pattern that allows adding new functionality to an object dynamically without modifying its structure. It is often used when we want to enhance the behavior of an object without altering its class or interface. This pattern is particularly useful in scenarios where the object’s functionality needs to be extended or modified at runtime, providing a flexible and reusable solution.
In the Decorator Pattern, a decorator class is created that wraps the original object and adds new functionality to it. This decorator class implements the same interface as the original object, allowing it to be used interchangeably. By using decorators, we can dynamically add or remove features from an object, making the code more modular and maintainable.
The Decorator Pattern consists of four main components:
1. Component: This is the base interface or abstract class that defines the common methods and properties for all objects in the system. It is the target object that can be decorated.
2. Concrete Component: This is a class that implements the Component interface and represents the concrete objects that can be decorated. It is the object that will be wrapped by the decorators.
3. Decorator: This is an abstract class or interface that implements the Component interface and defines an additional interface for adding new functionality. It maintains a reference to a Component object and delegates the calls to it.
4. Concrete Decorator: This is a class that extends the Decorator class and implements the additional functionality. It wraps the Concrete Component and adds new features to it.
Let’s consider an example to understand the Decorator Pattern better. Suppose we have a coffee shop where we can order different types of coffee with various toppings. We can use the Decorator Pattern to add different toppings to a coffee order without modifying the Coffee class.
Here’s a simple implementation of the Decorator Pattern for the coffee shop scenario:
“`python
Component
class Coffee:
def __init__(self):
self._description = “Basic Coffee”
def get_description(self):
return self._description
def cost(self):
return 1.0
Concrete Component
class Espresso(Coffee):
def __init__(self):
super().__init__()
self._description = “Espresso”
def cost(self):
return 2.0
Decorator
class CoffeeDecorator(Coffee):
def __init__(self, coffee):
self._coffee = coffee
def get_description(self):
return self._coffee.get_description()
def cost(self):
return self._coffee.cost()
Concrete Decorator
class Milk(CoffeeDecorator):
def __init__(self, coffee):
super().__init__(coffee)
def get_description(self):
return f”{self._coffee.get_description()} with Milk”
def cost(self):
return self._coffee.cost() + 0.5
Usage
coffee = Espresso()
coffee_with_milk = Milk(coffee)
print(coffee_with_milk.get_description()) Output: Espresso with Milk
print(coffee_with_milk.cost()) Output: 2.5
“`
In this example, the `Coffee` class represents the base coffee, and the `Espresso` class extends it to create a specific type of coffee. The `CoffeeDecorator` class acts as a decorator, while the `Milk` class extends it to add milk to the coffee. The resulting `coffee_with_milk` object has the description “Espresso with Milk” and a cost of 2.5, demonstrating the flexibility and reusability of the Decorator Pattern.
