11.4.2. Decorator Pattern

The Decorator Pattern adds responsibilities to objects dynamically.

The Decorator Pattern is a structural design pattern used to add new functionality or behavior to individual objects without altering their structure. This is useful when you want to enhance the capabilities of a class without using inheritance. Instead of creating subclasses for every possible combination of functionality, decorators allow you to build complex behavior dynamically at runtime.

Think of a basic coffee drink. On its own, it has a simple flavor. Now, imagine you want to make that coffee special by adding extra ingredients like milk or caramel. Rather than creating entirely new drinks for each combination (like 'milk coffee' or 'caramel coffee'), you can simply add the ingredients one by one to your existing base coffee. This flexibility is akin to how the Decorator Pattern works, where we stack decorators to enhance the original object without altering its core nature.

interface Coffee {
 String getDescription();
 int getCost();
}
class SimpleCoffee implements Coffee {
 public String getDescription() { return "Simple Coffee"; }
 public int getCost() { return 5; }
}

In this chunk, we see an interface named Coffee, which defines two methods: getDescription() and getCost(). The SimpleCoffee class implements this interface and provides basic descriptions and costs for a simple coffee drink. This sets the foundation for how coffee objects will be represented in terms of their behavior and attributes.

Imagine a coffee shop menu. The Coffee interface represents the generic entry on that menu that tells customers what to expect from any type of coffee. The SimpleCoffee is the simplest version of that coffee, just like how a 'black coffee' could be a basic item in a coffee shop, giving a straightforward idea of what a customer would get.

class MilkDecorator implements Coffee {
 private Coffee coffee;
 public MilkDecorator(Coffee coffee) { this.coffee = coffee; }
 public String getDescription() {
 return coffee.getDescription() + ", Milk";
 }
 public int getCost() {
 return coffee.getCost() + 2;
 }
}

This chunk introduces the MilkDecorator class, which also implements the Coffee interface. It takes an existing Coffee object as input and enhances it. The getDescription() method appends ', Milk' to the description of the coffee passed to the decorator, while the getCost() method adds an additional cost for the milk. This showcases how the pattern allows for extending functionality without modifying the original object.

Returning to our coffee shop example, adding milk to a coffee is akin to a customer asking to personalize their drink. Just as you could order a simple coffee and then request to add milk (which changes both the flavor and price slightly), the MilkDecorator does the same in code, enhancing the basic coffee functionality dynamically.

--