Java设计模式之组合模式

概念和作用

组合模式（Composite Pattern）是一种将对象组合成树形结构以表示“部分-整体”的层次结构。它使得用户可以以统一的方式处理单个对象和组合对象。在公司员工层级关系中，组合模式可以用来表示员工和部门之间的关系。

组成部分

组件（Component）：

定义了组合中所有对象的通用接口，可以是抽象类或接口。它声明了用于访问和管理子组件的方法，包括添加、删除、获取子组件等。

叶子节点（Leaf）：

表示组合中的叶子节点对象，叶子节点没有子节点。它实现了组件接口的方法，但通常不包含子组件。

容器节点（Composite）：

表示组合中的复合对象，复合节点可以包含子节点，可以是叶子节点，也可以是其他复合节点。它实现了组件接口的方法，包括管理子组件的方法。

客户端（Client）：

通过组件接口与组合结构进行交互，客户端不需要区分叶子节点和复合节点，可以一致地对待整体和部分。

举例

// 组件接口（Component），所有对象（树枝和叶子）都实现这个接口
interface EmployeeComponent {
    void add(EmployeeComponent employee);
    void remove(EmployeeComponent employee);
    void display();
}

// 叶子节点（Leaf）
class Employee implements EmployeeComponent {
    private String name;
    private String position;

    public Employee(String name, String position) {
        this.name = name;
        this.position = position;
    }

    // 因为叶子节点不能添加子节点，所以这里要报错
    @Override
    public void add(EmployeeComponent employee) {
        throw new UnsupportedOperationException("Cannot add to a leaf node.");
    }

    // 同上
    @Override
    public void remove(EmployeeComponent employee) {
        throw new UnsupportedOperationException("Cannot remove from a leaf node.");
    }

    @Override
    public void display() {
        System.out.println("Employee: " + name + " (" + position + ")");
    }
}

// 容器节点（Composite）
class Department implements EmployeeComponent {
    private String name;
    private List<EmployeeComponent> employees = new ArrayList<>();

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

    @Override
    public void add(EmployeeComponent employee) {
        employees.add(employee);
    }

    @Override
    public void remove(EmployeeComponent employee) {
        employees.remove(employee);
    }

    @Override
    public void display() {
        System.out.println("Department: " + name);
        for (EmployeeComponent employee : employees) {
            employee.display();
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Department hrDepartment = new Department("Human Resources");
        hrDepartment.add(new Employee("Alice", "HR Manager"));
        hrDepartment.add(new Employee("Bob", "Recruiter"));

        Department itDepartment = new Department("Information Technology");
        itDepartment.add(new Employee("Charlie", "IT Manager"));
        itDepartment.add(new Employee("Diana", "Software Engineer"));

        Department company = new Department("Company");
        company.add(hrDepartment);
        company.add(itDepartment);

        company.display();
    }
}

反例

如果不使用组合模式，我们需要为单个员工和部门分别处理，这会导致代码重复，并且难以维护。

class Employee {
    private String name;
    private String position;

    public Employee(String name, String position) {
        this.name = name;
        this.position = position;
    }

    public void display() {
        System.out.println("Employee: " + name + " (" + position + ")");
    }
}

class Department {
    private String name;
    private List<Employee> employees = new ArrayList<>();

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

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

    public void removeEmployee(Employee employee) {
        employees.remove(employee);
    }

    public void display() {
        System.out.println("Department: " + name);
        for (Employee employee : employees) {
            employee.display();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Employee alice = new Employee("Alice", "HR Manager");
        Employee bob = new Employee("Bob", "Recruiter");
        Department hrDepartment = new Department("Human Resources");
        hrDepartment.addEmployee(alice);
        hrDepartment.addEmployee(bob);

        Employee charlie = new Employee("Charlie", "IT Manager");
        Employee diana = new Employee("Diana", "Software Engineer");
        Department itDepartment = new Department("Information Technology");
        itDepartment.addEmployee(charlie);
        itDepartment.addEmployee(diana);

        System.out.println("HR Department:");
        hrDepartment.display();

        System.out.println("\nIT Department:");
        itDepartment.display();
    }
}

优点和缺点

优点

1.可以方便地将对象组合成树形结构，表示“部分-整体”的层次关系。

2.单个对象和组合对象具有相同的接口，用户可以以统一的方式处理它们。

3.增加新的组件类变得容易。

缺点

1.可能会导致设计中出现过多的抽象类或接口，从而增加系统的复杂性。

2.可能会使得系统的行为变得难以预测，因为用户可以以任何方式组合对象。