Design Patterns – Composite

Introduction to the Composite Pattern

The Composite pattern is a structural design pattern that allows you to compose objects into tree structures to represent part-whole hierarchies. It is used when clients need to treat individual objects and compositions of objects uniformly. The pattern simplifies the client code by allowing it to interact with complex structures of objects.

Key Components of the Composite Pattern

The Composite pattern involves the following key components:

• Component: The Component is an abstract class or interface that defines the common interface for both leaf and composite objects. It usually includes operations like adding, removing, and displaying children.
• Leaf: A Leaf is a class that implements the Component interface. It represents individual objects that do not have children. These are the building blocks of the composite structure.
• Composite: A Composite is a class that also implements the Component interface. It represents objects that can have children. A composite object can contain one or more child components, which can be either leaves or other composites.

Implementing the Composite Pattern

Let’s illustrate the Composite pattern with a simple example in Java. We will create a structure to represent a company’s organization hierarchy.

// Component
interface Employee {
    void showDetails();
}

// Leaf
class Developer implements Employee {
    private String name;

    public Developer(String name) {
        this.name = name;
    }

    public void showDetails() {
        System.out.println("Developer: " + name);
    }
}

// Composite
class Manager implements Employee {
    private String name;
    private List<Employee> team = new ArrayList<>();

    public Manager(String name) {
        this.name = name;
    }

    public void addEmployee(Employee employee) {
        team.add(employee);
    }

    public void showDetails() {
        System.out.println("Manager: " + name);
        for (Employee employee : team) {
            employee.showDetails();
        }
    }
}

// Client
public class CompositePatternExample {
    public static void main(String[] args) {
        Employee developer1 = new Developer("John");
        Employee developer2 = new Developer("Alice");

        Manager manager = new Manager("Bob");
        manager.addEmployee(developer1);
        manager.addEmployee(developer2);

        manager.showDetails();
    }
}

In this example, we have the Employee interface, two concrete leaf classes (Developer), and a composite class (ManagerManager class can contain one or more employees and displays the organization hierarchy.

Usage of the Composite Pattern

The Composite pattern is commonly used in various applications where you need to work with complex tree structures. Some common use cases include creating graphical user interfaces (GUIs), representing file systems, organizing components in a document, and managing hierarchical data structures.

Benefits of the Composite Pattern

The Composite pattern offers several advantages:

• Transparency: Clients can treat individual objects and compositions of objects uniformly, simplifying client code.
• Nesting: You can create complex structures by nesting composites within composites.
• Scalability: The pattern allows you to add new leaf and composite classes without affecting existing code.

Comparison with Other Patterns

The Composite pattern is often compared to the Decorator pattern, which is used to add responsibilities to individual objects. While both patterns allow for hierarchical object structures, the Composite pattern focuses on part-whole hierarchies, whereas the Decorator pattern focuses on extending an object’s behavior.

Conclusion

The Composite pattern is a powerful tool for modeling and working with complex structures. It simplifies the handling of individual objects and compositions of objects, making it easier to build flexible and scalable software systems in Java and other object-oriented languages.