设计模式之组合模式

组合模式的目的是将对象组合成树形结构以表示它们的层次结构。下面是一个简单的Java组合模式示例代码：

首先，定义一个接口，用于实现组合模式：

public interface Component {
    void performOperation();
}

然后，定义一个具体的类，实现Component接口：

public class ConcreteComponentA implements Component {
    @Override
    public void performOperation() {
        System.out.println("执行具体的操作A");
    }
}
public class ConcreteComponentB implements Component {
    @Override
    public void performOperation() {
        System.out.println("执行具体的操作B");
    }
}

接下来，定义一个抽象的类，它也实现了Component接口：

public abstract class CompositeComponent implements Component {
    protected List<Component> components;

    public CompositeComponent() {
        this.components = new ArrayList<>();
    }

    public void addComponent(Component component) {
        components.add(component);
    }

    public void removeComponent(Component component) {
        components.remove(component);
    }

    @Override
    public void performOperation() {
        for (Component component : components) {
            component.performOperation();
        }
    }
}

定义具体的类，实现抽象的类：

public class ConcreteCompositeComponentA extends CompositeComponent {
    public ConcreteCompositeComponentA() {
        super();
    }

    public void addComponent(Component component) {
        System.out.println("添加子组件");
        super.addComponent(component);
    }

    public void removeComponent(Component component) {
        System.out.println("删除子组件");
        super.removeComponent(component);
    }
}
public class ConcreteCompositeComponentB extends CompositeComponent {
    public ConcreteCompositeComponentB() {
        super();
    }

    public void addComponent(Component component) {
        System.out.println("添加子组件");
        super.addComponent(component);
    }

    public void removeComponent(Component component) {
        System.out.println("删除子组件");
        super.removeComponent(component);
    }
}

最后，客户端代码使用组合模式：

public class Client {
    public static void main(String[] args) {
        Component compositeComponentA = new ConcreteCompositeComponentA();
        Component compositeComponentB = new ConcreteCompositeComponentB();

        Component componentA = new ConcreteComponentA();
        Component componentB = new ConcreteComponentB();

        compositeComponentA.addComponent(componentA);
        compositeComponentA.addComponent(componentB);

        compositeComponentB.addComponent(componentA);
        compositeComponentB.addComponent(componentB);

        compositeComponentA.performOperation();
        compositeComponentB.performOperation();
    }
}

运行结果如下：

添加子组件
添加子组件
执行具体的操作A
执行具体的操作B
执行具体的操作A
执行具体的操作B
删除子组件
删除子组件

通过这种方式，客户端只需要知道有一个统一的接口Component，而无需关心具体的实现细节。当需要增加新的组合时，只需要添加一个新的实现类，而不需要修改现有的代码。这使得代码更加灵活，易于维护。