Decorator

The Decorator pattern is a structural design pattern that allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class. This pattern creates a decorator class which wraps the original class and provides additional functionality while keeping the class methods signature intact.

Imagine you have a class with a method that you want to extend without modifying the original class. You can create a decorator class that extends the original class and adds the new functionality. That means that the original class still adheres to the Open–Closed principle. The Decorator pattern is a good alternative to subclassing when you want to add new functionality to an object without changing its structure.

UML Diagram

+-------------------+        +-------------------+
|    Component      |<-------|  ConcreteComponent|
|-------------------|        |-------------------|
| +operation()      |        | +operation()      |
+-------------------+        +-------------------+
        ^
        |
+-------------------+
|   Decorator       |
|-------------------|
| -component: Component |
| +operation()      |
+-------------------+
        ^
        |
+-------------------+
| ConcreteDecorator |
|-------------------|
| +operation()      |
+-------------------+

In this diagram, Component is an interface with a method operation(). ConcreteComponent is a class that implements the Component interface. Decorator is an abstract class that also implements the Component interface and has a reference to a Component object. ConcreteDecorator is a class that extends Decorator and adds additional behavior to the operation() method.

--- Java Example ---

 // Component interface
 public interface Component {
     void operation();
 }

 // ConcreteComponent class
 public class ConcreteComponent implements Component {
     @Override
     public void operation() {
         System.out.println("ConcreteComponent operation");
     }
 }

 // Decorator abstract class
 public abstract class Decorator implements Component {
     protected Component component;

     public Decorator(Component component) {
         this.component = component;
     }

     @Override
     public void operation() {
         component.operation();
     }
 }

 // ConcreteDecorator class
 public class ConcreteDecorator extends Decorator {
     public ConcreteDecorator(Component component) {
         super(component);
     }

     @Override
     public void operation() {
         super.operation();
         addedBehavior();
     }

     private void addedBehavior() {
         System.out.println("ConcreteDecorator added behavior");
     }
 }

 // Client code
 public class Client {
     public static void main(String[] args) {
         Component component = new ConcreteComponent();
         Component decoratedComponent = new ConcreteDecorator(component);
         decoratedComponent.operation();
     }
 }

--- Python Example ---

 from __future__ import annotations
 from abc import ABC, abstractmethod

 # Component interface
 class Component(ABC):
     @abstractmethod
     def operation(self) -> None:
         pass

 # ConcreteComponent class
 class ConcreteComponent(Component):
     def operation(self) -> None:
         print("ConcreteComponent operation")

 # Decorator abstract class
 class Decorator(Component):
     _component: Component

     def __init__(self, component: Component) -> None:
         self._component = component

     def operation(self) -> None:
         self._component.operation()

 # ConcreteDecorator class
 class ConcreteDecorator(Decorator):
     def operation(self) -> None:
         super().operation()
         self._added_behavior()

     def _added_behavior(self) -> None:
         print("ConcreteDecorator added behavior")

 # Client code
 if __name__ == "__main__":
     component = ConcreteComponent()
     decorated_component = ConcreteDecorator(component)
     decorated_component.operation()