DukeDuke
主页
项目文档
技术文档
  • 单机版
  • 微服务
  • 代办项目
  • 优鲜项目
项目管理
关于我们
主页
项目文档
技术文档
  • 单机版
  • 微服务
  • 代办项目
  • 优鲜项目
项目管理
关于我们
  • 技术文档

    • 网络原理

      • 交换机
      • 路由器
      • TCP/IP协议
      • HTTP 与 HTTPS
    • 软件架构

      • 什么是软件架构
      • 分层架构
      • 微服务架构
      • 事件驱动架构
      • 领域驱动设计(DDD)
      • 架构图
      • 高并发系统
    • Vue3

      • Vue3简介
      • Vue3响应式系统
      • Vue3组合式API
      • Vue3生命周期
      • Vue3模板语法
      • Vue3组件系统
      • Vue3 路由系统
      • Vue3 状态管理
      • Vue3 性能优化
      • Vue3 TypeScript 支持
      • Vue3 项目实战
      • VUE 面试题大全
      • Node.js 安装
    • JAVA

      • JVM

        • 认识JVM
        • JVM类加载器
        • 运行时数据区
        • 执行引擎
        • 本地方法接口
        • 本地方法库
        • JVM垃圾回收
        • JVM性能监控
        • JVM调优
      • 设计模式
        • 单例模式
        • 工厂模式
        • 策略模式
        • 适配器模式
        • 建造者模式
        • 原型模式
        • 装饰器模式
        • 代理模式
        • 外观模式
        • 享元模式
        • 组合模式
        • 桥接模式
      • Java多线程

        • Java 线程基础详解
        • Java 线程池详解
        • Java ThreadLocal 详解
        • Java volatile 详解
        • Java 线程间通信详解
        • Java 线程安全详解
        • Java 线程调度详解
        • Java 线程优先级详解

        • Java 线程中断详解
        • Java 线程死锁详解
      • Java反射
      • Java 面试题

        • Java 基础概念面试题
        • Java 面向对象编程面试题
        • Java 集合框架面试题
        • Java 多线程与并发面试题
        • JVM 与内存管理面试题
        • Java I/O 与 NIO 面试题
        • Java 异常处理面试题
        • Java 反射与注解面试题
        • Java Spring 框架面试题
        • Java 数据库与 JDBC 面试题
        • Java 性能优化面试题
        • Java 实际项目经验面试题
        • Java 高级特性面试题
        • Java 面试准备建议
    • Python

      • Python简介
      • Python安装
      • Python hello world
      • Python基础语法
      • Python数据类型
      • Python数字
      • Python字符串
      • Python列表
      • Python元组
      • Python字典
      • Python日期时间
      • Python文件操作
      • Python异常处理
      • Python函数
      • Python类
      • Python模块
      • Python包
      • Python多线程
      • Python面向对象
      • Python爬虫
      • Django web框架
      • Python 面试题

        • Python 面试题导航
        • Python 基础概念
        • Python 面向对象编程
        • Python 数据结构
        • Python 高级特性
        • Python 框架
        • Python 性能优化
        • Python 项目经验
    • Spring

      • Spring
      • Springboot
      • Spring Security 安全框架
      • SpringBoot 中的事件详解
      • SpringBoot 中的定时任务详解
      • SpringBoot 自动装配原理与源码解释
    • Mybatis

      • Mybatis
      • Mybatis-Plus
    • 数据库

      • Redis

        • Redis简介
        • Redis(单机)安装
        • Redis配置
        • Redis数据结构
        • RDB、AOF 和混合持久化机制
        • Redis内存管理
        • Redis缓存一致性
        • Redis缓存穿透
        • Redis缓存击穿
        • Redis缓存雪崩
        • Redis Lua脚本
        • Redis主从复制
        • Redis哨兵模式
        • Redis集群
        • Redis数据分片
        • Redis CPU使用率过高
        • Redis面试题
      • MySQL

        • MySQL简介
        • MySQL安装
        • MySQL配置
        • MYSQL日常维护
        • MYSQL优化-慢查询
        • MYSQL优化-索引
        • MYSQL数据库设计规范
    • 消息队列

      • RocketMQ
      • Kafka
      • RabbitMQ
      • 消息队列面试题
    • 微服务

      • SpringCloud 微服务
      • Eureka 注册中心
      • Nacos 注册中心
      • Gateway 网关
      • Feign 服务调用
      • Sentinel 限流 与 熔断
      • Seata 分布式事务
      • CAP 理论
      • Redis 分布式锁
      • 高并发系统设计
    • ELK日志分析系统

      • Elasticsearch 搜索引擎
      • Logstash 数据处理
      • Kibana 可视化
      • ELK 实战
    • 开放API

      • 开放API设计
      • 开放API示例项目
    • 人工智能

      • 人工智能简介
      • 机器学习

      • 深度学习

      • 自然语言处理

      • 计算机视觉

        • CUDA与cuDNN详细安装
        • Conda 安装
        • Pytorch 深度学习框架
        • yolo 目标检测
        • TensorRT 深度学习推理优化引擎
        • TensorFlow 机器学习
        • CVAT 图像标注
        • Windows 下安装 CUDA、cuDNN、TensorRT、TensorRT-YOLO 环境
        • Windows10+CUDA+cuDNN+TensorRT+TensorRT-YOLO 部署高性能YOLO11推理
    • 大数据

      • 大数据简介
      • Hadoop 数据存储
      • Flume 数据采集
      • Sqoop 数据导入导出
      • Hive 数据仓库
      • Spark 数据处理
      • Flink 数据处理
      • Kafka 数据采集
      • HBase 数据存储
      • Elasticsearch 搜索引擎
    • 图像处理

      • 图像处理简介
      • 医学图像web呈现
      • 医学图像处理
      • 切片细胞分离问题
    • 服务器&运维

      • Linux 系统

        • Linux 系统管理
        • Linux 网络管理
        • Linux 文件管理
        • Linux 命令大全
      • Nginx Web 服务器

        • Nginx 安装 与 配置
        • Nginx 负载均衡
        • Nginx SSL证书配置
        • Nginx Keepalived 高可用
      • Docker 容器

        • Docker 简介
        • Docker 安装与配置
        • Docker 命令
        • Docker 部署 Nginx
        • Docker 部署 MySQL
        • Docker 部署 Redis
      • 服务器

        • 塔式服务器
        • 机架式服务器
        • 刀片服务器
      • Git 版本控制
      • Jenkins 持续集成
      • Jmeter 性能测试
      • Let's Encrypt 免费SSL证书
    • 简历

      • 项目经理简历
      • 开发工程师简历

组合模式

概述

组合模式(Composite Pattern)是一种结构型设计模式,它允许你将对象组合成树形结构来表现"整体/部分"层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

定义

组合模式将对象组合成树形结构以表示"部分-整体"的层次结构,使得用户对单个对象和组合对象的使用具有一致性。

结构

组合模式包含以下几个角色:

1. Component(抽象构件)

  • 为组合中的对象声明接口
  • 在适当的情况下,实现所有类共有接口的默认行为
  • 声明一个接口用于访问和管理 Component 的子部件
  • 在递归结构中定义一个接口,用于访问一个父部件,并在合适的情况下实现它

2. Leaf(叶子构件)

  • 在组合中表示叶子节点对象,叶子节点没有子节点
  • 在组合中定义图元对象的行为

3. Composite(容器构件)

  • 定义有子部件的那些部件的行为
  • 存储子部件
  • 在 Component 接口中实现与子部件有关的操作

优缺点

优点

  1. 统一处理:客户端可以统一地处理单个对象和组合对象,无需关心处理的是单个对象还是组合对象
  2. 易于扩展:新增构件类型时,不需要修改现有代码,符合开闭原则
  3. 简化客户端代码:客户端不需要知道对象的具体类型,只需要知道抽象类型
  4. 树形结构:天然支持树形结构的构建和管理

缺点

  1. 类型检查困难:在运行时检查对象类型时,可能会遇到类型转换的问题
  2. 设计复杂:过度使用组合模式会使设计变得复杂
  3. 性能问题:对于大型树形结构,遍历和查找可能会影响性能

适用场景

  1. 文件系统:文件和文件夹的层次结构
  2. 图形界面:窗口、面板、按钮等 UI 组件的层次结构
  3. 组织架构:公司、部门、员工的层次结构
  4. 菜单系统:菜单项和子菜单的层次结构
  5. XML 文档:元素和子元素的层次结构

实现示例

示例 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 class File extends FileSystemComponent {
    private long size;

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

    @Override
    public void display(int depth) {
        String indent = "  ".repeat(depth);
        System.out.println(indent + "文件: " + name + " (" + size + " bytes)");
    }

    @Override
    public long getSize() {
        return size;
    }
}

// 容器构件 - 文件夹
public class Directory extends FileSystemComponent {
    private List<FileSystemComponent> children = new ArrayList<>();

    public Directory(String name) {
        super(name);
    }

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

    public void remove(FileSystemComponent component) {
        children.remove(component);
    }

    @Override
    public void display(int depth) {
        String indent = "  ".repeat(depth);
        System.out.println(indent + "文件夹: " + 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 class Client {
    public static void main(String[] args) {
        // 创建文件系统结构
        Directory root = new Directory("根目录");

        Directory documents = new Directory("文档");
        documents.add(new File("报告.docx", 1024));
        documents.add(new File("计划.xlsx", 2048));

        Directory pictures = new Directory("图片");
        pictures.add(new File("照片1.jpg", 5120));
        pictures.add(new File("照片2.jpg", 6144));

        root.add(documents);
        root.add(pictures);
        root.add(new File("说明.txt", 512));

        // 显示文件系统结构
        System.out.println("文件系统结构:");
        root.display(0);

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

示例 2:图形界面组件

// 抽象构件
public abstract class UIComponent {
    protected String name;

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

    public abstract void render();
    public abstract void add(UIComponent component);
    public abstract void remove(UIComponent component);
    public abstract UIComponent getChild(int index);
}

// 叶子构件 - 按钮
public class Button extends UIComponent {
    public Button(String name) {
        super(name);
    }

    @Override
    public void render() {
        System.out.println("渲染按钮: " + name);
    }

    @Override
    public void add(UIComponent component) {
        throw new UnsupportedOperationException("按钮不能添加子组件");
    }

    @Override
    public void remove(UIComponent component) {
        throw new UnsupportedOperationException("按钮不能移除子组件");
    }

    @Override
    public UIComponent getChild(int index) {
        throw new UnsupportedOperationException("按钮没有子组件");
    }
}

// 叶子构件 - 文本框
public class TextBox extends UIComponent {
    public TextBox(String name) {
        super(name);
    }

    @Override
    public void render() {
        System.out.println("渲染文本框: " + name);
    }

    @Override
    public void add(UIComponent component) {
        throw new UnsupportedOperationException("文本框不能添加子组件");
    }

    @Override
    public void remove(UIComponent component) {
        throw new UnsupportedOperationException("文本框不能移除子组件");
    }

    @Override
    public UIComponent getChild(int index) {
        throw new UnsupportedOperationException("文本框没有子组件");
    }
}

// 容器构件 - 面板
public class Panel extends UIComponent {
    private List<UIComponent> children = new ArrayList<>();

    public Panel(String name) {
        super(name);
    }

    @Override
    public void render() {
        System.out.println("渲染面板: " + name);
        for (UIComponent child : children) {
            child.render();
        }
    }

    @Override
    public void add(UIComponent component) {
        children.add(component);
    }

    @Override
    public void remove(UIComponent component) {
        children.remove(component);
    }

    @Override
    public UIComponent getChild(int index) {
        return children.get(index);
    }
}

与其他模式的关系

  1. 与装饰器模式:组合模式关注的是对象的结构,而装饰器模式关注的是对象的行为
  2. 与访问者模式:组合模式可以与访问者模式结合使用,对树形结构进行遍历和操作
  3. 与迭代器模式:组合模式可以与迭代器模式结合使用,提供统一的遍历接口

总结

组合模式是一种非常实用的结构型设计模式,特别适用于需要表示"整体-部分"层次结构的场景。它通过统一的接口来处理单个对象和组合对象,简化了客户端代码,提高了系统的可扩展性。

在实际开发中,组合模式常用于文件系统、图形界面、组织架构等场景。合理使用组合模式可以使代码更加清晰、易于维护。

最近更新:: 2025/8/14 09:20
Contributors: Duke
Prev
享元模式
Next
桥接模式