🎁 Decorator Design Pattern — LLD + Java + Real Use Cases

Add behavior to individual objects dynamically without altering their structure — a flexible alternative to subclassing.

---

🧠 What is the Decorator Pattern?

The Decorator Pattern is a structural design pattern that allows you to:

• Attach additional responsibilities to objects at runtime
• Wrap objects with other objects that enhance behavior
• Maintain the original object’s interface

---

📦 Use Cases (Real-World)

Context	Example
☕ Coffee Shop	Add milk, sugar, etc. to base beverage dynamically
🧾 Billing System	Add discounts, taxes, coupons to final price
📄 I/O Streams (Java)	BufferedReader, DataInputStream, GZIPOutputStream
🛡️ Security Layering	Add logging, auth, audit, throttling to requests
🧪 Testing Mocks	Mock + Spy + Log enhancement

---

🎯 When to Use It?

✅ Use when:

• You need to add features to objects dynamically and transparently
• You want to avoid subclass explosion
• You want to compose behavior in a flexible way

🚫 Avoid if:

• Object configuration is overly complex
• All variations are known at compile time (prefer inheritance)

---

🧱 Pattern Structure

Component	Role
Component (interface)	Declares the core operation
ConcreteComponent	The base implementation
Decorator (abstract)	Holds a reference to a Component + delegates
ConcreteDecorator	Adds extra behavior before/after delegate calls

---

📐 UML Diagram

+------------------+
|   Component      | <<interface>>
+------------------+
| +operation()     |
+------------------+
        ▲
        |
+-------------------+
| ConcreteComponent |
+-------------------+
| +operation()      |
+-------------------+
        ▲
        |
+-------------------+
|    Decorator      | <<abstract>>
+-------------------+
| - component: Component
| +operation()      |
+-------------------+
        ▲
+--------------------------+
|  ConcreteDecoratorA      |
+--------------------------+
| +operation()             |
+--------------------------+

---

☕ Coffee Shop Example in Java

✅ Beverage.java

public interface Beverage {
    String getDescription();
    double getCost();
}

---

✅ Espresso.java (ConcreteComponent)

public class Espresso implements Beverage {
    @Override
    public String getDescription() {
        return "Espresso";
    }

    @Override
    public double getCost() {
        return 100.0;
    }
}

---

✅ BeverageDecorator.java (Abstract Decorator)

public abstract class BeverageDecorator implements Beverage {
    protected Beverage beverage;

    public BeverageDecorator(Beverage beverage) {
        this.beverage = beverage;
    }
}

---

✅ MilkDecorator.java (ConcreteDecorator)

public class MilkDecorator extends BeverageDecorator {
    public MilkDecorator(Beverage beverage) {
        super(beverage);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }

    @Override
    public double getCost() {
        return beverage.getCost() + 20.0;
    }
}

---

✅ SugarDecorator.java

public class SugarDecorator extends BeverageDecorator {
    public SugarDecorator(Beverage beverage) {
        super(beverage);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Sugar";
    }

    @Override
    public double getCost() {
        return beverage.getCost() + 10.0;
    }
}

---

✅ Client.java

public class DecoratorClient {
    public static void main(String[] args) {
        Beverage espresso = new Espresso();
        System.out.println("Order 1: " + espresso.getDescription() + " | ₹" + espresso.getCost());

        Beverage customCoffee = new MilkDecorator(new SugarDecorator(new Espresso()));
        System.out.println("Order 2: " + customCoffee.getDescription() + " | ₹" + customCoffee.getCost());
    }
}

---

🧪 Output

Order 1: Espresso | ₹100.0
Order 2: Espresso, Sugar, Milk | ₹130.0

---

✨ Benefits

Advantage	Explanation
✅ Flexible composition	Add features without changing existing classes
✅ Open/Closed Principle	Extend behavior via composition
✅ Reuse & layering	Chain decorators to build behavior stacks
✅ No subclass explosion	Avoid subclassing for each variation

---

⚠️ Limitations

• 🎛️ Complex configuration if decorators are stacked dynamically
• 🧩 Debugging stack layers may be harder than single-class hierarchies

---

🧾 Summary

Feature	Value
Type	Structural
Primary Intent	Add behavior at runtime
Key Concepts Used	Composition, Delegation
Java Real Usage	InputStream, Logger, UI themes, Spring AOP

---