结构型模式-组合模式

组合模式（Composite Pattern）是一种结构型设计模式，它通过将对象组合成树形结构来表示"部分-整体"的层次结构，从而使客户端对单个对象和组合对象的使用具有一致性。

适用场景

需要表示对象的层次结构：如文件系统、组织结构图等。
客户端需要统一对待单个对象和组合对象：避免客户端分辨"这是一个简单对象"还是"这是一个复杂组合"。

主要角色

抽象组件（Component）

定义统一的接口或抽象类，为所有单个对象和组合对象提供公共操作。例如，定义通用操作方法，如add、remove和getChild。
叶子节点（Leaf）

表示树的叶子节点，无法继续包含子对象。实现抽象组件的操作。
组合对象（Composite）

表示可能包含子节点的复杂对象。它实现抽象组件，并持有子组件的集合。
客户端（Client）

通过抽象组件与对象交互，无需关心它是叶子节点还是组合对象。

示例代码

java 复制代码

public abstract class Component {
    public void add(Component component) {
        throw new UnsupportedOperationException("不支持操作");
    }
    public void remove(Component component) {
        throw new UnsupportedOperationException("不支持操作");
    }
    public Component getChild(int i) {
        throw new UnsupportedOperationException("不支持操作");
    }
    public abstract void operation(); // 抽象方法
}
//叶子节点
public class Leaf extends Component {
    private String name;

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

    @Override
    public void operation() {
        System.out.println("执行叶子节点操作：" + name);
    }
}
//组合对象
import java.util.ArrayList;
import java.util.List;

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

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

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

    @Override
    public Component getChild(int i) {
        return children.get(i);
    }

    @Override
    public void operation() {
        System.out.println("执行组合对象操作");
        for (Component child : children) {
            child.operation(); // 递归调用子对象的操作
        }
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建叶子节点
        Component leaf1 = new Leaf("Leaf1");
        Component leaf2 = new Leaf("Leaf2");
        
        // 创建组合对象
        Composite composite = new Composite();
        composite.add(leaf1);
        composite.add(leaf2);
        
        // 创建更大的组合
        Composite root = new Composite();
        root.add(composite);
        root.add(new Leaf("Leaf3"));

        // 执行操作
        root.operation();
    }
}

优缺点

优点
高扩展性：添加新的组件（叶子或组合）时无需修改现有代码。
一致性：客户端代码可以一致地处理单个对象和组合对象。
缺点
可能影响性能：对于包含大量子对象的组合对象，操作时会递归调用。
过于通用：可能导致组件类的接口过于庞大。
这种模式在树形结构的处理中非常实用，尤其是对于递归操作和统一接口的需求场景，比如操作系统的文件系统、UI 组件树等。