组合模式：叶子与容器一视同仁，以及它和装饰者到底差在哪

/** 没有组合时：调用方被迫按类型分支，而且每加一种节点就要改一次 */
void printAll(Object org, String indent) {
    if (org instanceof Employee) {
        System.out.println(indent + ((Employee) org).getName());
    } else if (org instanceof Department) {
        Department dept = (Department) org;
        System.out.println(indent + dept.getName());
        for (Object child : dept.getChildren()) {
            printAll(child, indent + "  ");     // 递归分支也跟着类型走
        }
    } else {
        throw new IllegalArgumentException("未知节点类型");
    }
}

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

/** Component：叶子与容器统一对外暴露的接口 */
abstract class OrgUnit {
    protected final String name;

    protected OrgUnit(String name) {
        this.name = name;
    }

    /** 人数 */
    abstract int headcount();

    /** 月薪合计（单位：分） */
    abstract long salaryFen();

    /** 默认只打印自己；容器覆盖它做递归 */
    void print(String indent) {
        System.out.println(indent + name);
    }
}

/** Leaf：员工，没有子节点 */
class Employee extends OrgUnit {
    private final long monthlySalaryFen;

    Employee(String name, long monthlySalaryFen) {
        super(name);
        this.monthlySalaryFen = monthlySalaryFen;
    }

    @Override
    int headcount() {
        return 1;                                   // 叶子的"规模"就是它自己
    }

    @Override
    long salaryFen() {
        return monthlySalaryFen;
    }

    @Override
    void print(String indent) {
        System.out.println(indent + "· " + name + "（" + monthlySalaryFen / 100 + " 元/月）");
    }
}

/** Composite：部门——既是 OrgUnit，又持有一组 OrgUnit */
class Department extends OrgUnit {
    private final List<OrgUnit> children = new ArrayList<>();

    Department(String name) {
        super(name);
    }

    void add(OrgUnit unit) {
        children.add(unit);
    }

    void remove(OrgUnit unit) {
        children.remove(unit);
    }

    @Override
    int headcount() {
        int total = 0;
        for (OrgUnit child : children) {
            total += child.headcount();              // 递归：叶子返回 1，子部门继续往下拆
        }
        return total;
    }

    @Override
    long salaryFen() {
        long total = 0L;
        for (OrgUnit child : children) {
            total += child.salaryFen();
        }
        return total;
    }

    @Override
    void print(String indent) {
        System.out.println(indent + name + "（" + headcount() + " 人）");
        for (OrgUnit child : children) {
            child.print(indent + "  ");             // 递归：叶子与容器都只认 print
        }
    }
}

public class CompositeDemo {
    public static void main(String[] args) {
        Employee zhang = new Employee("张三", 1200000L);   // 12000 元
        Employee li = new Employee("李四", 1500000L);
        Employee wang = new Employee("王五", 900000L);

        Department backend = new Department("后端组");
        backend.add(zhang);
        backend.add(li);

        Department tech = new Department("技术部");
        tech.add(backend);
        tech.add(wang);

        // 客户端统一对待：单个员工和整个部门走同一套接口
        System.out.println("技术部人数：" + tech.headcount());
        System.out.println("技术部月薪合计：" + tech.salaryFen() / 100 + " 元");
        System.out.println();
        tech.print("");
        System.out.println();
        System.out.println("单个员工人数：" + zhang.headcount());
    }
}

技术部人数：3
技术部月薪合计：36000 元

技术部（3 人）
  后端组（2 人）
    · 张三（12000 元/月）
    · 李四（15000 元/月）
  · 王五（9000 元/月）

单个员工人数：1

abstract class OrgUnit {
    // 默认实现：叶子继承后调用就抛异常
    void add(OrgUnit unit) {
        throw new UnsupportedOperationException(name + " 是叶子节点，不支持 add");
    }

    void remove(OrgUnit unit) {
        throw new UnsupportedOperationException(name + " 是叶子节点，不支持 remove");
    }
}

class Department extends OrgUnit {
    void add(OrgUnit unit)    { children.add(unit); }
    void remove(OrgUnit unit) { children.remove(unit); }
}

// 客户端：必须先知道它是 Department
if (node instanceof Department) {
    ((Department) node).add(new Employee("赵六", 800000L));
}