组合模式案例

wen java案例 2026-08-09 166

本文目录导读：

组合模式案例

什么是组合模式？
基础案例：文件系统
进阶案例：组织结构管理
安全组合 vs 透明组合
实战案例：菜单系统
组合模式总结

我将为你展示组合模式的完整案例,从基础概念到实际应用。

什么是组合模式？

组合模式允许你将对象组合成树形结构来表示“部分-整体”的层次关系，让客户端可以一致地处理单个对象和组合对象。

基础案例：文件系统

1 组件接口

// 抽象组件
public abstract class FileSystemComponent {
    protected String name;
    public FileSystemComponent(String name) {
        this.name = name;
    }
    public abstract void display(int depth);
    public abstract long getSize();
    // 默认实现，叶子节点不需要重写
    public void add(FileSystemComponent component) {
        throw new UnsupportedOperationException();
    }
    public void remove(FileSystemComponent component) {
        throw new UnsupportedOperationException();
    }
    public FileSystemComponent getChild(int index) {
        throw new UnsupportedOperationException();
    }
    protected String getIndent(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("  ");
        }
        return sb.toString();
    }
}

2 叶子节点 - 文件

// 叶子节点：文件
public class File extends FileSystemComponent {
    private long size;  // 文件大小（字节）
    public File(String name, long size) {
        super(name);
        this.size = size;
    }
    @Override
    public void display(int depth) {
        System.out.println(getIndent(depth) + "📄 " + name + " (" + formatSize(size) + ")");
    }
    @Override
    public long getSize() {
        return size;
    }
    private String formatSize(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
        return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
    }
}

3 复合节点 - 文件夹

// 复合节点：文件夹
public class Folder extends FileSystemComponent {
    private List<FileSystemComponent> children = new ArrayList<>();
    private Date createDate;
    public Folder(String name) {
        super(name);
        this.createDate = new Date();
    }
    @Override
    public void add(FileSystemComponent component) {
        children.add(component);
    }
    @Override
    public void remove(FileSystemComponent component) {
        children.remove(component);
    }
    @Override
    public FileSystemComponent getChild(int index) {
        return children.get(index);
    }
    @Override
    public void display(int depth) {
        System.out.println(getIndent(depth) + "📁 " + name + "/");
        for (FileSystemComponent child : children) {
            child.display(depth + 1);
        }
    }
    @Override
    public long getSize() {
        long totalSize = 0;
        for (FileSystemComponent child : children) {
            totalSize += child.getSize();
        }
        return totalSize;
    }
    public int getChildCount() {
        return children.size();
    }
    public boolean isEmpty() {
        return children.isEmpty();
    }
    public List<FileSystemComponent> getChildren() {
        return children;
    }
}

4 客户端测试代码

public class FileSystemClient {
    public static void main(String[] args) {
        // 创建文件系统结构
        Folder root = new Folder("C:");
        // 创建目录结构
        Folder windows = new Folder("Windows");
        Folder programFiles = new Folder("Program Files");
        Folder users = new Folder("Users");
        // Windows目录内容
        File system32 = new File("system32.dll", 5 * 1024 * 1024);
        File explorer = new File("explorer.exe", 3 * 1024 * 1024);
        windows.add(system32);
        windows.add(explorer);
        // Program Files目录内容
        Folder java = new Folder("Java");
        Folder python = new Folder("Python");
        programFiles.add(java);
        programFiles.add(python);
        // Java目录内容
        File javac = new File("javac.exe", 2 * 1024 * 1024);
        File jar = new File("jar.exe", 1 * 1024 * 1024);
        java.add(javac);
        java.add(jar);
        // Users目录内容
        File report = new File("report.doc", 2048);
        File photo = new File("photo.jpg", 5 * 1024 * 1024);
        users.add(report);
        users.add(photo);
        // 组装树结构
        root.add(windows);
        root.add(programFiles);
        root.add(users);
        // 显示整个文件系统
        System.out.println("=== 文件系统结构 ===");
        root.display(0);
        // 计算总大小
        System.out.println("\n=== 总大小统计 ===");
        System.out.println("C: 总大小: " + formatSize(root.getSize()));
        System.out.println("Windows: " + formatSize(windows.getSize()));
        System.out.println("Program Files: " + formatSize(programFiles.getSize()));
        System.out.println("Users: " + formatSize(users.getSize()));
        // 统一处理叶子节点和复合节点
        System.out.println("\n=== 统一处理演示 ===");
        processComponent(root);
    }
    // 统一处理方法，不需要区分是文件还是文件夹
    private static void processComponent(FileSystemComponent component) {
        System.out.println("处理: " + component.name);
        if (component instanceof Folder) {
            Folder folder = (Folder) component;
            for (FileSystemComponent child : folder.getChildren()) {
                processComponent(child);
            }
        }
    }
    private static String formatSize(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
        return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
    }
}

进阶案例：组织结构管理

1 组织架构组件

// 抽象组件
public abstract class OrganizationComponent {
    protected String name;
    protected String position;
    public OrganizationComponent(String name, String position) {
        this.name = name;
        this.position = position;
    }
    public abstract void show(int depth);
    public abstract double calculateSalary();
    public abstract int getEmployeeCount();
    // 树形操作方法
    public void add(OrganizationComponent component) {
        throw new UnsupportedOperationException();
    }
    public void remove(OrganizationComponent component) {
        throw new UnsupportedOperationException();
    }
    public OrganizationComponent getChild(int index) {
        throw new UnsupportedOperationException();
    }
    protected String getIndent(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("  ");
        }
        return sb.toString();
    }
}

2 员工（叶子节点）

public class Employee extends OrganizationComponent {
    private double baseSalary;
    private double bonus;
    private String department;
    public Employee(String name, String position, String department, 
                   double baseSalary, double bonus) {
        super(name, position);
        this.department = department;
        this.baseSalary = baseSalary;
        this.bonus = bonus;
    }
    @Override
    public void show(int depth) {
        System.out.println(getIndent(depth) + "👤 " + name + " | " + position + 
                         " | " + department + " | 薪资: " + calculateSalary());
    }
    @Override
    public double calculateSalary() {
        return baseSalary + bonus;
    }
    @Override
    public int getEmployeeCount() {
        return 1;
    }
}

3 部门（复合节点）

public class Department extends OrganizationComponent {
    private List<OrganizationComponent> members = new ArrayList<>();
    private String description;
    private double departmentBonus;
    public Department(String name, String position, String description) {
        super(name, position);
        this.description = description;
        this.departmentBonus = 0;
    }
    @Override
    public void add(OrganizationComponent component) {
        members.add(component);
    }
    @Override
    public void remove(OrganizationComponent component) {
        members.remove(component);
    }
    @Override
    public OrganizationComponent getChild(int index) {
        return members.get(index);
    }
    @Override
    public void show(int depth) {
        System.out.println(getIndent(depth) + "🏢 [" + name + "] " + 
                         position + " - " + description);
        for (OrganizationComponent member : members) {
            member.show(depth + 1);
        }
    }
    @Override
    public double calculateSalary() {
        double total = 0;
        for (OrganizationComponent member : members) {
            total += member.calculateSalary();
        }
        return total;
    }
    @Override
    public int getEmployeeCount() {
        int count = 0;
        for (OrganizationComponent member : members) {
            count += member.getEmployeeCount();
        }
        return count;
    }
    // 部门特有的方法
    public void setDepartmentBonus(double bonus) {
        this.departmentBonus = bonus;
    }
    public String getDescription() {
        return description;
    }
}

4 客户端测试

public class OrganizationClient {
    public static void main(String[] args) {
        // 创建公司结构
        Department company = new Department("TechCorp", "总公司", "科技创新公司");
        // 创建部门
        Department techDept = new Department("技术部", "技术部门", "负责产品研发");
        Department salesDept = new Department("销售部", "销售部门", "负责市场销售");
        Department hrDept = new Department("人力资源部", "人事部门", "负责人员管理");
        // 技术部门员工
        Employee techManager = new Employee("张三", "技术总监", "技术部", 30000, 10000);
        Employee dev1 = new Employee("李四", "高级开发工程师", "技术部", 20000, 5000);
        Employee dev2 = new Employee("王五", "开发工程师", "技术部", 15000, 3000);
        // 创建技术部子团队
        Department frontendTeam = new Department("前端组", "团队", "负责前端开发");
        Department backendTeam = new Department("后端组", "团队", "负责后端开发");
        Employee frontend1 = new Employee("赵六", "前端工程师", "技术部", 12000, 2000);
        Employee frontend2 = new Employee("钱七", "前端工程师", "技术部", 12000, 2000);
        Department frontendArchitect = new Department("架构组", "子团队", "负责架构设计");
        frontendTeam.add(frontend1);
        frontendTeam.add(frontend2);
        frontendArchitect.add(new Employee("孙八", "首席架构师", "技术部", 25000, 8000));
        frontendTeam.add(frontendArchitect);
        backendTeam.add(dev1);
        backendTeam.add(dev2);
        techDept.add(techManager);
        techDept.add(frontendTeam);
        techDept.add(backendTeam);
        // 销售部门
        Employee salesManager = new Employee("周九", "销售总监", "销售部", 15000, 10000);
        Employee sales1 = new Employee("吴十", "销售代表", "销售部", 8000, 2000);
        Employee sales2 = new Employee("郑十一", "销售代表", "销售部", 8000, 2000);
        salesDept.add(salesManager);
        salesDept.add(sales1);
        salesDept.add(sales2);
        // 人力资源部门
        Employee hrManager = new Employee("王十二", "HR总监", "人力资源部", 10000, 3000);
        Employee hr1 = new Employee("李十三", "HR", "人力资源部", 5000, 1000);
        hrDept.add(hrManager);
        hrDept.add(hr1);
        // 组装公司结构
        company.add(techDept);
        company.add(salesDept);
        company.add(hrDept);
        // 显示公司组织架构
        System.out.println("=== 公司组织架构 ===");
        company.show(0);
        // 统计信息
        System.out.println("\n=== 公司统计信息 ===");
        System.out.println("员工总数: " + company.getEmployeeCount() + " 人");
        System.out.println("月度总薪资: ¥" + String.format("%,.2f", company.calculateSalary()));
        // 统计各部门
        System.out.println("\n=== 各部门统计 ===");
        statDepartment(techDept, "技术部");
        statDepartment(salesDept, "销售部");
        statDepartment(hrDept, "人力资源部");
        // 安全删除操作
        System.out.println("\n=== 安全删除测试 ===");
        try {
            Employee emp = new Employee("测试", "测试", "测试", 0, 0);
            emp.show(0);  // 叶子节点可以显示
            emp.add(new Employee("非法", "操作", "测试", 0, 0));  // 会抛出异常
        } catch (UnsupportedOperationException e) {
            System.out.println("正确抛出异常: " + e.getMessage());
        }
    }
    private static void statDepartment(Department dept, String name) {
        System.out.println(name + ": " + dept.getEmployeeCount() + " 人, " + 
                         "薪资: ¥" + String.format("%,.2f", dept.calculateSalary()));
    }
}

安全组合 vs 透明组合

1 安全组合模式（推荐）

// 安全模式：接口只定义叶子节点的方法
public abstract class SafeComponent {
    protected String name;
    public SafeComponent(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public abstract void operation();
}
// 叶子节点
public class Leaf extends SafeComponent {
    public Leaf(String name) {
        super(name);
    }
    @Override
    public void operation() {
        System.out.println("叶子节点: " + name + " 执行操作");
    }
}
// 复合节点 - 有自己的管理模式
public class Composite extends SafeComponent {
    private List<SafeComponent> children = new ArrayList<>();
    public Composite(String name) {
        super(name);
    }
    public void add(SafeComponent component) {
        children.add(component);
    }
    public void remove(SafeComponent component) {
        children.remove(component);
    }
    public SafeComponent getChild(int index) {
        return children.get(index);
    }
    @Override
    public void operation() {
        System.out.println("复合节点: " + name + " 执行操作");
        for (SafeComponent child : children) {
            child.operation();
        }
    }
}

实战案例：菜单系统

// 菜单组件接口
public abstract class MenuComponent {
    protected String name;
    protected String description;
    public MenuComponent(String name, String description) {
        this.name = name;
        this.description = description;
    }
    public abstract void print();
    public abstract double getPrice();
    public void add(MenuComponent menuComponent) {
        throw new UnsupportedOperationException();
    }
    public void remove(MenuComponent menuComponent) {
        throw new UnsupportedOperationException();
    }
    public MenuComponent getChild(int i) {
        throw new UnsupportedOperationException();
    }
    protected String getIndent(int depth) {
        return "  ".repeat(depth);
    }
}
// 菜单项（叶子节点）
public class MenuItem extends MenuComponent {
    private double price;
    private boolean vegetarian;
    public MenuItem(String name, String description, double price, boolean vegetarian) {
        super(name, description);
        this.price = price;
        this.vegetarian = vegetarian;
    }
    @Override
    public void print() {
        System.out.println("  " + name + (vegetarian ? "(素食)" : "") + 
                         " - $" + price);
        System.out.println("    " + description);
    }
    @Override
    public double getPrice() {
        return price;
    }
}
// 菜单（复合节点）
public class Menu extends MenuComponent {
    private List<MenuComponent> menuComponents = new ArrayList<>();
    public Menu(String name, String description) {
        super(name, description);
    }
    @Override
    public void add(MenuComponent menuComponent) {
        menuComponents.add(menuComponent);
    }
    @Override
    public void remove(MenuComponent menuComponent) {
        menuComponents.remove(menuComponent);
    }
    @Override
    public MenuComponent getChild(int i) {
        return menuComponents.get(i);
    }
    @Override
    public void print() {
        System.out.println("\n=== " + name + " ===");
        System.out.println(description);
        System.out.println("---------------------");
        for (MenuComponent component : menuComponents) {
            component.print();
        }
    }
    @Override
    public double getPrice() {
        double total = 0;
        for (MenuComponent component : menuComponents) {
            total += component.getPrice();
        }
        return total;
    }
}
// 测试代码
public class MenuClient {
    public static void main(String[] args) {
        // 创建总菜单
        Menu allMenu = new Menu("全部菜单", "所有菜单选项");
        // 创建分类菜单
        Menu breakfastMenu = new Menu("早餐菜单", "早晨特供");
        Menu lunchMenu = new Menu("午餐菜单", "中午精选");
        Menu dinnerMenu = new Menu("晚餐菜单", "傍晚推荐");
        // 添加早餐菜单项
        breakfastMenu.add(new MenuItem("鸡蛋三明治", "全麦面包配煎蛋和蔬菜", 5.99, false));
        breakfastMenu.add(new MenuItem("燕麦粥", "新鲜燕麦配水果", 3.99, true));
        // 创建午餐子菜单
        Menu mainCourseMenu = new Menu("主菜", "午餐主菜");
        Menu dessertMenu = new Menu("甜点", "美味甜点");
        mainCourseMenu.add(new MenuItem("烤鸡沙拉", "新鲜蔬菜配烤鸡胸肉", 8.99, false));
        mainCourseMenu.add(new MenuItem("素食意面", "番茄酱配意大利面", 6.99, true));
        dessertMenu.add(new MenuItem("提拉米苏", "传统意大利甜点", 4.99, true));
        dessertMenu.add(new MenuItem("草莓蛋糕", "新鲜草莓配奶油蛋糕", 3.99, true));
        lunchMenu.add(mainCourseMenu);
        lunchMenu.add(dessertMenu);
        // 添加晚餐菜单项
        dinnerMenu.add(new MenuItem("牛排套餐", "精选牛肉配时蔬", 19.99, false));
        dinnerMenu.add(new MenuItem("烤鱼", "时令鲜鱼配柠檬汁", 15.99, false));
        // 组装菜单
        allMenu.add(breakfastMenu);
        allMenu.add(lunchMenu);
        allMenu.add(dinnerMenu);
        // 打印菜单
        allMenu.print();
        // 计算总价
        System.out.println("\n=== 总价计算 ===");
        System.out.printf("全部菜单总价: $%.2f%n", allMenu.getPrice());
        System.out.printf("午餐菜单总价: $%.2f%n", lunchMenu.getPrice());
        System.out.printf("早餐菜单总价: $%.2f%n", breakfastMenu.getPrice());
    }
}

组合模式总结

1 模式结构

┌─────────────────────────────────────────────────────┐
│                 Component (抽象组件)                  │
│  - 定义所有对象的通用方法                               │
│  - 提供默认实现                                      │
└─────────────────────────────────────────────────────┘
                    ▲                    ▲
                   /  \                  |
    ┌─────────────┘    └─────────────┐   |
    │                                │   │
┌──────────────┐            ┌────────────────┐
│ Leaf (叶子)   │            │ Composite (复合) │
│ - 没有子节点   │            │ - 包含子节点     │
│ - 实现具体操作 │            │ - 管理子节点     │
└──────────────┘            └────────────────┘

2 优缺点

优点：

统一接口：客户端可以一致地处理单个对象和组合对象
简化客户端代码：不需要区分处理叶子节点和复合节点
易于扩展：可以轻松增加新的组件类型
天然递归：适合处理树形结构

缺点：

设计泛化：可能会让设计过于一般化，难以限制组件类型
性能问题：对树进行遍历时可能会有性能开销
安全与透明权衡：需要权衡安全组合和透明组合

3 适用场景

树形结构：文件系统、组织架构、菜单系统
递归结构：XML/HTML解析、JSON处理
图形界面：容器组件和独立组件
数据模型：目录树、分类树

4 实际应用案例

// Java AWT/Swing中的容器层次
// Java标准库中的目录结构
// 工作流引擎中的任务分解
// 电商系统中的商品分类
// 实际项目示例：多级分类
public class CategoryExample {
    public static void main(String[] args) {
        CategoryComponent root = new Category("电子产品");
        CategoryComponent phone = new Category("手机");
        CategoryComponent notebook = new Category("笔记本");
        phone.add(new Product("iPhone 15", 6999));
        phone.add(new Product("华为 Mate 60", 5999));
        CategoryComponent gaming = new Category("游戏本");
        gaming.add(new Product("联想拯救者", 7999));
        notebook.add(gaming);
        root.add(phone);
        root.add(notebook);
        // 显示所有产品
        root.print();
    }
}

组合模式是处理树形结构数据的重要设计模式,在实际开发中应用广泛，掌握了它能够让代码更加简洁、灵活和可扩展。

本文地址： https://bmjup.com/post/42285.html