组合模式¶

package com.example.structural.composite;

/**
 * 组合模式 - 反例
 * 问题：用 instanceof 判断是文件还是目录，新增节点类型需要修改所有这样的方法
 */
public class CompositeBadExample {
    public static void main(String[] args) {
        // 构造文件系统树
        DirectoryBad root = new DirectoryBad("root");
        root.addChild(new FileBad("a.txt", 100));
        DirectoryBad docs = new DirectoryBad("docs");
        docs.addChild(new FileBad("b.pdf", 500));
        docs.addChild(new FileBad("c.md",  200));
        root.addChild(docs);

        System.out.println("总大小: " + calculateSize(root) + " bytes");
    }

    // ❌ 使用 instanceof 区分叶子和容器，扩展性差
    static long calculateSize(Object node) {
        if (node instanceof FileBad f) {
            return f.getSize();
        } else if (node instanceof DirectoryBad d) {
            long total = 0;
            for (Object child : d.getChildren()) {
                total += calculateSize(child); // 递归时仍需 instanceof
            }
            return total;
        }
        return 0; // ❌ 新增类型就得修改这里
    }
}

// 叶子节点
class FileBad {
    private final String name;
    private final long   size;
    public FileBad(String name, long size) { this.name = name; this.size = size; }
    public long getSize() { return size; }
    public String getName() { return name; }
}

// 容器节点（与 FileBad 无公共接口）
class DirectoryBad {
    private final String        name;
    private final java.util.List<Object> children = new java.util.ArrayList<>();
    public DirectoryBad(String name) { this.name = name; }
    public void addChild(Object child)           { children.add(child); }
    public java.util.List<Object> getChildren()  { return children;     }
    public String getName()                       { return name;         }
}

package com.example.structural.composite;

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

/**
 * 组合模式 - 正例
 * 文件和目录实现同一接口，客户端无需区分，递归操作自然统一
 */
public class CompositeExample {
    public static void main(String[] args) {
        // ✅ 构造文件系统树（叶子和容器都是 FileSystemNode）
        FileSystemNode root = new Directory("root");
        root.add(new FileLeaf("a.txt", 100));

        FileSystemNode docs = new Directory("docs");
        docs.add(new FileLeaf("b.pdf", 500));
        docs.add(new FileLeaf("c.md",  200));
        root.add(docs);

        // ✅ 对 root 调用 getSize()，不需要 instanceof，多态自动处理
        System.out.println("总大小: " + root.getSize() + " bytes"); // 800
        root.print("");
    }
}

// 统一组件接口
interface FileSystemNode {
    long   getSize();
    void   print(String indent);
    default void add(FileSystemNode node) { throw new UnsupportedOperationException(); }
}

// 叶子节点：文件
class FileLeaf implements FileSystemNode {
    private final String name;
    private final long   size;

    public FileLeaf(String name, long size) { this.name = name; this.size = size; }

    @Override public long getSize()              { return size; }
    @Override public void print(String indent)   { System.out.println(indent + "📄 " + name + " (" + size + "B)"); }
}

// 容器节点：目录（可包含任意 FileSystemNode）
class Directory implements FileSystemNode {
    private final String              name;
    private final List<FileSystemNode> children = new ArrayList<>();

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

    @Override
    public void add(FileSystemNode node) { children.add(node); }

    @Override
    public long getSize() {
        // ✅ 对所有子节点调用同一接口，无需 instanceof
        return children.stream().mapToLong(FileSystemNode::getSize).sum();
    }

    @Override
    public void print(String indent) {
        System.out.println(indent + "📁 " + name + " (" + getSize() + "B)");
        children.forEach(c -> c.print(indent + "  "));
    }
}

void print(Object node) {
    if (node instanceof MenuItem) {               // 叶子节点
        System.out.println(((MenuItem) node).getName());
    } else if (node instanceof Menu) {            // 容器节点
        for (Object child : ((Menu) node).getChildren()) {
            print(child);  // 每次新增节点类型都要改这里，违反开闭原则
        }
    }
}

public abstract class HumanResource {
    protected long id;
    // 统一接口：叶子返回自身薪资，容器递归汇总子节点
    public abstract double calculateSalary();
}

public class Employee extends HumanResource {
    private double salary;
    @Override
    public double calculateSalary() { return salary; }
}

public class Department extends HumanResource {
    private List<HumanResource> subNodes = new ArrayList<>();
    @Override
    public double calculateSalary() {
        // 无需区分子节点是 Employee 还是 Department，统一调用接口
        return subNodes.stream().mapToDouble(HumanResource::calculateSalary).sum();
    }
    public void addSubNode(HumanResource node) { subNodes.add(node); }
}