Composite

The Composite pattern is a structural design pattern that allows you to compose objects into tree structures to represent part-whole hierarchies. This pattern lets clients treat individual objects and compositions of objects uniformly.

In layman’s terms, imagine a company where you have employees and managers. Managers can have their own employees, and those employees can be managers of other employees. The Composite pattern allows you to treat both employees and managers uniformly, so you can perform operations on them without worrying whether you’re dealing with a simple employee or a manager with a team.

UML Diagram

    +-------------------+
    |     Component     |
    |-------------------|
    | +operation()      |
    +-------------------+
            ^
            |
    +-------+-----------+
    |                   |
+---+-------+       +---+-------+
| Leaf      |       |Composite  |
|-----------|       |-----------|
|operation()|       |operation()|
+-----------+       |add()      |
                    |remove()   |
                    |getChild() |
                    +-----------+

--- Java Example ---

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

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

// Composite class
public class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    @Override
    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }

    public void add(Component component) {
        children.add(component);
    }

    public void remove(Component component) {
        children.remove(component);
    }

    public Component getChild(int index) {
        return children.get(index);
    }
}

// Client code
public class Client {
    public static void main(String[] args) {
        Component leaf1 = new Leaf();
        Component leaf2 = new Leaf();
        Composite composite = new Composite();
        composite.add(leaf1);
        composite.add(leaf2);

        composite.operation(); // Outputs: Leaf operation \n Leaf operation
    }
}

--- Python Example ---

 from typing import List, Protocol

 # Component interface
 class Component(Protocol):
     def operation(self) -> None:
         pass

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

 # Composite class
 class Composite(Component):
     def __init__(self) -> None:
         self.children: List[Component] = []

     def operation(self) -> None:
         for child in self.children:
             child.operation()

     def add(self, component: Component) -> None:
         self.children.append(component)

     def remove(self, component: Component) -> None:
         self.children.remove(component)

     def get_child(self, index: int) -> Component:
         return self.children[index]

 # Client code
 if __name__ == "__main__":
     leaf1 = Leaf()
     leaf2 = Leaf()
     composite = Composite()
     composite.add(leaf1)
     composite.add(leaf2)

     composite.operation()  # Outputs: Leaf operation \n Leaf operation