组合模式如何实现递归

组合模式（Composite Pattern）实现递归的核心思想是：
让“单个对象”和“组合对象”实现同一个接口，组合对象内部再持有多个该接口的子对象，从而形成一个递归结构。

下面我从 思想 → 结构 → 代码示例 → 递归调用过程 四个方面说明。

一、组合模式为什么能实现递归？

组合模式的目标是：

把“部分-整体”关系用树形结构表示，并让客户端以一致的方式处理单个对象和组合对象。

关键点在于：

• 组合对象内部包含自身类型的子节点
• 对组合对象的操作，通常会递归调用子节点的同名操作

这正是递归的本质。

二、组合模式的结构

1️⃣ 角色说明

Component（抽象组件）
 ├── Leaf（叶子节点）
 └── Composite（组合节点）

• Component

  • 定义统一的接口
  • 通常会声明“可能被递归调用的方法”（如 operation()、print()）

• Leaf（叶子）

  • 表示最小单位
  • 没有子节点
  • 实现具体操作

• Composite（组合）

  • 持有多个 Component
  • 在方法中递归调用子组件的方法

三、经典示例：文件和文件夹

1️⃣ 抽象组件

public interface FileComponent {
    void print();
}

2️⃣ 叶子节点（文件）

public class File implements FileComponent {

    private String name;

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

    @Override
    public void print() {
        System.out.println("文件：" + name);
    }
}

3️⃣ 组合节点（文件夹）

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

public class Folder implements FileComponent {

    private String name;
    private List<FileComponent> children = new ArrayList<>();

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

    public void add(FileComponent component) {
        children.add(component);
    }

    @Override
    public void print() {
        System.out.println("文件夹：" + name);
        // ✅ 递归调用
        for (FileComponent child : children) {
            child.print();
        }
    }
}

4️⃣ 客户端使用

public class Client {
    public static void main(String[] args) {

        File f1 = new File("a.txt");
        File f2 = new File("b.txt");

        Folder subFolder = new Folder("子文件夹");
        subFolder.add(f1);

        Folder root = new Folder("根文件夹");
        root.add(subFolder);
        root.add(f2);

        root.print();
    }
}

四、递归是如何发生的？

调用过程如下：

root.print()
 └── 文件夹：根文件夹
     ├── subFolder.print()
     │    └── 文件夹：子文件夹
     │         └── a.txt
     └── b.txt

✅ 递归的本质：

• Folder.print() 调用了 child.print()
• child 可能是 Folder，也可能是 File
• 如果是 Folder，就会继续向下递归

五、组合模式实现递归的关键点总结

✅ 接口统一

叶子节点和组合节点实现同一个接口

✅ 组合节点持有自身类型的集合

List<FileComponent> children;

✅ 组合节点在方法中递归调用子节点方法

✅ 递归终止条件由叶子节点隐式提供

叶子节点不再继续调用子节点

六、常见误区

❌ 认为只有“递归函数”才算递归
✅ 对象结构 + 方法调用链 也是递归

❌ 让叶子节点也维护子节点
✅ 只有 Composite 才维护子节点

七、一句话总结

组合模式通过“统一接口 + 树形结构 + 组合对象递归调用子对象”，天然实现了递归。

如果你愿意，我也可以：

• 用 C++ / Python 给你写一版
• 结合 安全式 vs 透明式组合模式 对比
• 用 UML 图 再解释一遍