11.4.3. Composite Pattern

The Composite Pattern is used where you need to treat individual objects and compositions of objects uniformly.

The Composite Pattern is a structural design pattern that allows you to create tree-like structures of objects. This means that you can treat both individual objects and groups of objects in the same way. This is useful when you want to represent part-whole hierarchies, where a single object can stand in for a composition of objects. It simplifies client code because clients don’t need to differentiate between single objects and groups.

Imagine a company organization where both individual employees and groups of employees (like departments) need to be managed. A manager can look at a single developer just as easily as they can look at an entire department that includes multiple developers. The Composite Pattern allows for this level of abstraction, treating both as if they are the same.

interface Employee {
void showDetails();
}```

The Employee interface defines a common method, showDetails, that all employee types will implement. This abstraction is fundamental to the Composite Pattern because it allows any concrete implementation of Employee—whether it is a single employee or a group of employees—to be treated uniformly in the client code.

Think of the Employee interface as a job description. Regardless of position, every employee (whether a developer or a manager) has to give their job details. This means that whether you're talking to a software developer or a hiring manager, they all report their duties the same way.

class Developer implements Employee {
public void showDetails() {
System.out.println("Developer");
}
}```

The Developer class implements the Employee interface. When the showDetails method is called on an instance of Developer, it will print 'Developer'. This shows how individual employees can provide their own specific details when requested by the client.

If the employee is a software developer, calling their showDetails might be like having them introduce themselves in a meeting: they might say, 'I am a Developer'. Every individual can share their identity in their own words.

class Manager implements Employee {
List<Employee> employees = new ArrayList<>();
public void add(Employee e) { employees.add(e); }
public void showDetails() {
for (Employee e : employees) {
e.showDetails();
}
}
}```

The Manager class also implements the Employee interface and can contain a list of Employees (both Developers and other Managers). It provides an add method to add employees to its list. When calling showDetails, it will iterate through its list of employees and call showDetails on each, allowing the manager to display details for all its employees at once, demonstrating the hierarchy.

Imagine a family gathering where the head of the family (the manager) wants to introduce everyone. Instead of introducing each individual one-by-one, they can say, 'Let me introduce my children, spouse, and relatives’ while listing them off in one go. The manager summarizes the details of everyone working under them.

--