什么是组合模式？

组合模式是一种结构型设计模式，它允许你将对象组合成树形结构来表现"部分-整体"的层次结构。组合模式使得客户端可以统一地对待单个对象和对象组合，从而使得系统更加灵活。

在组合模式中，有两种基本类型的对象：叶子对象和容器对象。叶子对象表示树形结构中的叶子节点，它们不再包含任何子节点。容器对象表示树形结构中的分支节点，它们可以包含叶子对象和容器对象。

在组合模式中，所有对象都实现同一个接口，客户端可以通过该接口来操作对象，而不需要知道具体是叶子对象还是容器对象。同时，容器对象中会包含一组子对象，客户端可以通过容器对象的接口来访问和操作这些子对象。

组合模式的优点

组合模式的优点包括：

• 客户端代码可以统一地对待单个对象和对象组合，从而简化了代码。
• 可以通过组合方式来实现对整个树形结构的操作，从而使得代码更加灵活。
• 可以通过容器对象来动态地添加或删除叶子对象或容器对象，从而使得系统更加易于扩展。

组合模式的缺点

组合模式的缺点包括：

• 对于叶子对象和容器对象，它们实现的方法不一样，可能会导致代码的复杂性增加。
• 对于大型的树形结构，可能会导致系统的性能下降。

组合模式的应用场景

组合模式适用于那些需要表示部分-整体层次结构的问题，以及那些需要对整个层次结构进行操作的问题。具体的应用场景包括：

• 文件系统中的目录和文件。
• UI控件中的容器控件和叶子控件。
• 图形编辑器中的图形对象和组合对象。
• 组织机构中的部门和员工。

组合模式的实现方式

组合模式的实现方式包括：

• 定义一个抽象的 Component 类来声明公共的操作接口。
• 定义一个 Leaf 类来表示叶子对象，实现 Component 接口。
• 定义一个 Composite 类来表示容器对象，实现 Component 接口，并包含一个子对象列表。
• 在 Composite 类中实现 Component 接口的操作方法，通过递归的方式调用子对象的操作方法。

组合模式的实例代码

下面是一个使用组合模式来实现文件目录管理的示例代码，代码使用了 Java

我们首先定义一个抽象类 TreeNode，表示树中的节点，包括文件和文件夹。该类包含了一些公共方法，比如获取名称、获取大小等。

public abstract class TreeNode {
    private String name;
    private int size;

    public TreeNode(String name, int size) {
        this.name = name;
        this.size = size;
    }

    public String getName() {
        return name;
    }

    public int getSize() {
        return size;
    }

    public abstract void add(TreeNode node);

    public abstract void remove(TreeNode node);

    public abstract List<TreeNode> getChildren();

    public abstract boolean isFile();

    public void print(int level) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < level; i++) {
            sb.append("-");
        }
        System.out.println(sb.toString() + getName() + " (" + getSize() + ")");
        for (TreeNode child : getChildren()) {
            child.print(level + 1);
        }
    }
}

然后，我们定义一个 FileNode 类，表示文件。该类继承自 TreeNode 类，并实现了添加和删除节点的方法，但因为它是文件节点，所以这些方法什么也不做。

public class FileNode extends TreeNode {
    public FileNode(String name, int size) {
        super(name, size);
    }

    @Override
    public void add(TreeNode node) {
        // do nothing
    }

    @Override
    public void remove(TreeNode node) {
        // do nothing
    }

    @Override
    public List<TreeNode> getChildren() {
        return new ArrayList<>();
    }

    @Override
    public boolean isFile() {
        return true;
    }
}

接下来，我们定义一个 FolderNode 类，表示文件夹。该类也继承自 TreeNode 类，并包含了一个 List 类型的成员变量 children，用于存储子节点。

import java.util.ArrayList;
import java.util.List;

public class FolderNode extends TreeNode {
    private List<TreeNode> children = new ArrayList<>();

    public FolderNode(String name) {
        super(name, 0);
    }

    @Override
    public void add(TreeNode node) {
        children.add(node);
        setSize(getSize() + node.getSize());
    }

    @Override
    public void remove(TreeNode node) {
        children.remove(node);
        setSize(getSize() - node.getSize());
    }

    @Override
    public List<TreeNode> getChildren() {
        return children;
    }

    @Override
    public boolean isFile() {
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        TreeNode file1 = new FileNode("file1.txt", 10);
        TreeNode file2 = new FileNode("file2.txt", 20);
        TreeNode file3 = new FileNode("file3.txt", 30);

        TreeNode folder1 = new FolderNode("folder1");
        folder1.add(file1);
        folder1.add(file2);

        TreeNode folder2 = new FolderNode("folder2");
        folder2.add(file3);

        TreeNode root = new FolderNode("root");
        root.add

root (60)
-folder1 (30)
--file1.txt (10)
--file2.txt (20)
-folder2 (30)
--file3.txt (30)

类图