设计模式之组合模式

已于 2024-05-18 14:22:06 修改
阅读量1.9k 收藏 9
点赞数 5
分类专栏： 23种设计模式 文章标签： 设计模式 组合模式
于 2024-03-05 15:18:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41883161/article/details/136479755
版权

组合模式（Composite Pattern）是一种结构型设计模式，它将对象组合成树形结构，以表示“部分-整体”的层次结构。通过这种方式，客户端可以统一地处理单个对象和组合对象。组合模式特别适合处理具有树状层次结构的数据，例如文件系统、组织架构、图形界面等。

定义

组合模式通过创建一个包含叶子节点和组合节点的树结构，使客户端可以对单个对象和组合对象进行一致的处理。组合模式的定义如下：

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

使用场景

组合模式的主要使用场景包括：

  1. 具有层次结构的数据：当你的程序需要处理类似树形结构的数据时，例如文件系统、公司组织架构、图形界面组件等，组合模式非常适合。
  2. 统一的操作方式：当你希望客户端能够以统一的方式处理单个对象和组合对象时，使用组合模式可以简化客户端代码。
  3. 递归结构的处理：组合模式可以通过递归方式处理复杂的层次结构，使得处理过程更加简洁。

主要角色

组合模式的主要角色包括：

  1. Component（组件）：定义所有组件的通用接口，包括叶子节点和组合节点。
  2. Leaf（叶子节点）：表示树的叶子节点，叶子节点没有子节点。
  3. Composite（组合节点）：表示包含子节点的组合节点，可以包含叶子节点和其他组合节点。

类图

下图展示了组合模式的类图结构：

Composite Pattern Class Diagram

示例代码

安全模式

在安全模式中，叶子节点和组合节点实现相同的接口，但叶子节点不支持添加子节点的方法。这种方式确保了类型安全，避免了客户端错误地调用叶子节点的添加方法。

// Component 接口
public interface FileSystemComponent {
    void display();
}

// 叶子节点 - File
public class File implements FileSystemComponent {
    private final String name;

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

    @Override
    public void display() {
        System.out.println("File: " + name);
    }
}

// 组合节点 - Folder
public class Folder implements FileSystemComponent {
    private final String name;
    private final List<FileSystemComponent> components;

    public Folder(String name) {
        this.name = name;
        this.components = new ArrayList<>();
    }

    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    @Override
    public void display() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建文件和文件夹
        File file1 = new File("file1.txt");
        File file2 = new File("file2.txt");
        Folder folder1 = new Folder("Folder 1");
        Folder folder2 = new Folder("Folder 2");

        // 组合节点包含叶子节点
        folder1.addComponent(file1);
        folder1.addComponent(file2);

        // 组合节点包含另一个组合节点
        folder2.addComponent(folder1);

        // 显示整个文件系统结构
        folder2.display();
    }
}

输出结果：

Folder: Folder 2
Folder: Folder 1
File: file1.txt
File: file2.txt

透明模式

在透明模式中，所有的组件（无论是叶子节点还是组合节点）都实现相同的接口，包括添加和删除子节点的方法。这样客户端可以统一地处理所有的组件，但需要注意叶子节点的添加和删除方法会抛出不支持操作的异常。

// Component 接口
public interface FileSystemComponent {
    void display();
    void addComponent(FileSystemComponent component);
}

// 叶子节点 - File
public class File implements FileSystemComponent {
    private final String name;

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

    @Override
    public void display() {
        System.out.println("File: " + name);
    }

    @Override
    public void addComponent(FileSystemComponent component) {
        throw new UnsupportedOperationException(this.name + "是文件,不支持添加");
    }
}

// 组合节点 - Folder
public class Folder implements FileSystemComponent {
    private final String name;
    private final List<FileSystemComponent> components;

    public Folder(String name) {
        this.name = name;
        this.components = new ArrayList<>();
    }

    @Override
    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    @Override
    public void display() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建文件和文件夹
        FileSystemComponent file1 = new File("file1.txt");
        FileSystemComponent file2 = new File("file2.txt");
        FileSystemComponent folder1 = new Folder("Folder 1");
        FileSystemComponent folder2 = new Folder("Folder 2");

        // 组合节点包含叶子节点
        folder1.addComponent(file1);
        folder1.addComponent(file2);

        // 组合节点包含另一个组合节点
        folder2.addComponent(folder1);

        // 显示整个文件系统结构
        folder2.display();
    }
}

输出结果：

Folder: Folder 2
Folder: Folder 1
File: file1.txt
File: file2.txt

组合模式的优缺点

优点

  1. 简化客户端代码：客户端可以统一地处理叶子节点和组合节点，无需区分它们的具体类型。
  2. 易于扩展：添加新的叶子节点和组合节点类型不需要修改现有代码，符合开闭原则。
  3. 递归处理：通过递归方式处理树状结构，使得代码简洁而清晰。

缺点

  1. 类型安全问题：在透明模式下，叶子节点和组合节点都实现相同的接口，可能导致运行时异常。
  2. 复杂性增加：对于简单的结构，使用组合模式可能导致不必要的复杂性。

实际应用

组合模式广泛应用于各种需要处理树形结构的场景，例如：

  1. 文件系统：文件系统中的文件和文件夹可以通过组合模式来实现，文件夹可以包含文件和其他文件夹。
  2. 图形界面：图形界面中的组件（例如按钮、文本框、容器等）可以通过组合模式来组织，容器可以包含其他组件。
  3. 组织架构：公司组织架构中的员工和部门可以通过组合模式来表示，部门可以包含员工和其他部门。

进一步的示例

文件系统示例

在实际开发中，文件系统是组合模式的经典应用场景。我们可以扩展上述示例，增加更多的功能，例如删除组件、获取组件的名称等。

// Component 接口
public interface FileSystemComponent {
    void display();
    void addComponent(FileSystemComponent component);
    void removeComponent(FileSystemComponent component);
    String getName();
}

// 叶子节点 - File
public class File implements FileSystemComponent {
    private final String name;

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

    @Override
    public void display() {
        System.out.println("File: " + name);
    }

    @Override
    public void addComponent(FileSystemComponent component) {
        throw new UnsupportedOperationException(this.name + "是文件,不支持添加");
    }

    @Override
    public void removeComponent(FileSystemComponent component) {
        throw new UnsupportedOperationException(this.name + "是文件,不支持删除");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

// 组合节点 - Folder
public class Folder implements FileSystemComponent {
    private final String name;
    private final List<FileSystemComponent> components;

    public Folder(String name) {
        this.name = name;
        this.components = new ArrayList<>();
    }

    @Override
    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    @Override
    public void removeComponent(FileSystemComponent component) {
        components.remove(component);
    }

    @Override
    public void display() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }

    @Override
    public String getName() {
        return this.name;
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建文件和文件夹
        FileSystemComponent file1 = new File("file1.txt");
        FileSystemComponent file2 = new File("file2.txt");
        FileSystemComponent folder1 = new Folder("Folder 1");
        FileSystemComponent folder2 = new Folder("Folder 2");

        // 组合节点包含叶子节点
        folder1.addComponent(file1);
        folder1.addComponent(file2);

        // 组合节点包含另一个组合节点
        folder2.addComponent(folder1);

        // 显示整个文件系统结构
        folder2.display();

        // 移除一个文件
        folder1.removeComponent(file1);
        folder2.display();
    }
}

输出结果：

Folder: Folder 2
Folder: Folder 1
File: file1.txt
File: file2.txt

Folder: Folder 2
Folder: Folder 1
File: file2.txt

图形界面示例

另一个实际应用是图形界面系统，组合模式可以用于表示和管理界面组件。例如，我们可以创建一个简单的图形界面框架，包含按钮、文本框和容器。

// Component 接口
public interface UIComponent {
    void render();
    void addComponent(UIComponent component);
    void removeComponent(UIComponent component);
    String getName();
}

// 叶子节点 - Button
public class Button implements UIComponent {
    private final String name;

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

    @Override
    public void render() {
        System.out.println("Button: " + name);
    }

    @Override
    public void addComponent(UIComponent component) {
        throw new UnsupportedOperationException(this.name + "是按钮,不支持添加");
    }

    @Override
    public void removeComponent(UIComponent component) {
        throw new UnsupportedOperationException(this.name + "是按钮,不支持删除");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

// 叶子节点 - TextBox
public class TextBox implements UIComponent {
    private final String name;

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

    @Override
    public void render() {
        System.out.println("TextBox: " + name);
    }

    @Override
    public void addComponent(UIComponent component) {
        throw new UnsupportedOperationException(this.name + "是文本框,不支持添加");
    }

    @Override
    public void removeComponent(UIComponent component) {
        throw new UnsupportedOperationException(this.name + "是文本框,不支持删除");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

// 组合节点 - Container
public class Container implements UIComponent {
    private final String name;
    private final List<UIComponent> components;

    public Container(String name) {
        this.name = name;
        this.components = new ArrayList<>();
    }

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

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

    @Override
    public void render() {
        System.out.println("Container: " + name);
        for (UIComponent component : components) {
            component.render();
        }
    }

    @Override
    public String getName() {
        return this.name;
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建界面组件
        UIComponent button1 = new Button("Button 1");
        UIComponent button2 = new Button("Button 2");
        UIComponent textBox1 = new TextBox("TextBox 1");
        UIComponent container1 = new Container("Container 1");
        UIComponent container2 = new Container("Container 2");

        // 组合容器包含按钮和文本框
        container1.addComponent(button1);
        container1.addComponent(textBox1);

        // 组合容器包含另一个容器
        container2.addComponent(container1);
        container2.addComponent(button2);

        // 渲染整个界面
        container2.render();

        // 移除一个按钮
        container2.removeComponent(button2);
        container2.render();
    }
}

输出结果：

Container: Container 2
Container: Container 1
Button: Button 1
TextBox: TextBox 1
Button: Button 2

Container: Container 2
Container: Container 1
Button: Button 1
TextBox: TextBox 1

总结

组合模式是一种强大的结构型设计模式，它通过将对象组合成树形结构，使得客户端可以统一地处理单个对象和组合对象。通过上述示例可以看到，组合模式在处理复杂的层次结构时非常有用，无论是文件系统、图形界面，还是组织架构，都可以通过组合模式来实现更加简洁和灵活的代码结构。

在实际开发中，选择安全模式还是透明模式需要根据具体的需求和设计权衡。安全模式更加严格，防止类型错误，但在使用上稍显不便；透明模式则提供了更大的灵活性，但需要客户端处理潜在的运行时异常。

无论选择哪种模式，组合模式都能帮助开发者构建更易于维护和扩展的系统。通过组合模式，我们可以在处理复杂层次结构时保持代码的简洁性和一致性，从而提升开发效率和代码质量。

九转成圣
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式之组合模式
01-20
在GOF的《设计模式:可复用面向对象软件的基础》一书中对组合模式是这样说的：将对象组合成树形结构以表示“部分-整体”的层次结构。组合（Composite）模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式...
设计模式之组合模式(C++)
热门推荐
翟天保的博客
03-30 2万+
介绍设计模式之组合模式
JAVA设计模式之组合模式
孔子说
11-18 3449
转自http://www.kongzid.com/archives/design10，组合(Composite)模式是一种对象的行为模式。将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式的本质：统一叶子对象和组合对象。 组合模式的目的：让客户端不再区分操作的是组合对象还是叶子对象，而是以一个统一的方式来操作。 从上图可以看出，文件系统是一个树结构，树上长有节点。树的...
JavaScript 设计模式之组合模式
仇益阳的博客
12-02 1万+
引 我们知道地球和一些其他行星围绕着太阳旋转，也知道在一个原子中，有许多电子围绕着原子核旋转。我曾经想象，我们的太阳系也许是一个更大世界里的一个原子，地球只是围绕着太阳原子的一个电子。而我身上的每个原子又是一个星系，原子核就是这个星系中的恒星，电子是围绕着恒星旋转的行星。一个电子中也许还包含了另一个宇宙，虽然这个宇宙还不能被显微镜看到，但我相信它的存在。 也许这个想法有些异想天开，但在程序设计中，...
Java设计模式之组合模式详解
CSU_hjh的博客
12-21 2070
文章目录详解Java设计模式之组合模式案例引入组合模式定义模式类图结构相关角色典型代码案例分析类图设计实例代码结果分析JavaJDK中的组合模式透明组合模式安全组合模式组合模式优点组合模式缺点组合模式适用环境 详解Java设计模式之组合模式 案例引入 Windows的操作系统目录结构如下 分析 在树形目录结构中，包含文件和文件夹两类不同的元素 在文件家中可以继续包含子文件夹 在文件中不能在包含子文件（word中嵌入图片不是一个概念） 文件夹也叫作容器（Container）节点 文件也叫作叶
JAVA设计模式之组合模式详解
励志成为一名优秀的全能型软件开发工程师。
02-08 1839
组合模式(Composite Pattern) 的定义是：将对象组合成树形结构以表示整个部分的层次结构.组合模式可以让用户统一对待单个对象和对象的组合.比如: windows操作系统中的目录结构,其实就是树形目录结构,通过tree命令实现树形结构展示.在上图中包含了文件夹和文件两类不同元素,其中在文件夹中可以包含文件,还可以继续包含子文件夹.子文件夹中可以放入文件,也可以放入子文件夹. 文件夹形成了一种容器结构(树形结构),递归结构.
Java 设计模式之组合模式
swadian2008的博客
04-13 1957
在 Java 组合模式中，抽象构件角色定义了所有叶子节点和容器节点共有的方法和属性，其中包括添加、移除子节点、获取子节点等方法。容器节点角色表示树形结构中的非叶子节点，它包含了其他的组合对象或叶子对象，可以用于组织和管理它所包含的子节点。定义容器构件（Composite）类，它是组合中的容器节点对象，它可以包含子节点，也可以有自己的方法和属性。在该类中通常包含一个用于存储子节点的容器。在客户端代码中使用组合模式构建对象树，通过调用容器节点的方法来增加、删除子节点，通过调用叶子节点的方法来访问节点数据。
设计模式之组合模式详解（附应用举例实现）
pursuit的博客
04-25 5158
设计模式之组合模式详解（附应用举例实现）
《JAVA设计模式系列》组合模式
追寻心的步伐
08-30 1623
抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）。树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。高层模块调用简单：组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码。树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。......
设计模式之组合模式(Composite)
意田天的博客
06-11 1万+
组合模式 介绍 组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。 代码演示 package com.cyc.design.composite; import java.util.ArrayList; import java.util.List; /** * 组合模式 */ abstract class Node {
C++设计模式之组合模式(Composite)
08-27
C++设计模式之组合模式（Composite） 组合模式（Composite）是一种结构型设计模式，用于描述分支包含关系，也就是我们说的树形关系。其对象分为枝和叶，每一枝可包含枝和叶，直到全部为叶节点。 组合模式的主要...
第六天：java设计模式、GUI编程与面向对象设计原则
最新发布
JavaUpgrade
08-13 251
设计模式的定义：回顾设计模式的定义，即解决特定设计问题的通用解决方案。常见设计模式：了解并掌握几种常见的设计模式，如单例模式、工厂模式、策略模式、观察者模式等。了解它们的基本结构、应用场景和优缺点。设计模式的应用：通过实际例子或练习，尝试将设计模式应用到Java代码中，以解决实际问题。
【1】设计模式简介
2201_75414908的博客
08-12 181
设计模式简介
Spring Boot 常用设计模式
萧曳丶
08-06 1135
在Spring Boot中，常用的设计模式多种多样，这些设计模式不仅帮助维护了代码的清晰度和灵活性，还使得框架易于扩展和维护。
编程-设计模式 29：前端控制器模式
qq_45831414的博客
08-11 383
定义：前端控制器模式是一种用于Web应用程序的模式，它提供了一个统一的入口点来处理所有的客户端请求。前端控制器负责接收客户端的请求，并将请求转发给合适的处理程序。目的：该模式的主要目的是通过集中处理所有请求，简化应用程序的结构，同时提供统一的安全性、身份验证、错误处理等功能。
面试实战题-其他知识（设计模式）
sinat_27143551的博客
08-12 434
采用多种decoder/encoder 支持，对TCP粘包/分包进行自动化处理 可使用接受/处理线程池，提高连接效率，对重连、心跳检测的简单支持 可配置IO线程数、TCP参数， TCP接收和发送缓冲区使用直接内存代替堆内存，通过内存池的方式循环利用ByteBuf 通过引用计数器及时申请释放不再引用的对象，降低了GC频率 使用单线程串行化的方式，高效的Reactor线程模型 大量使用了volitale、使用了CAS和原子类、线程安全类的使用、读写锁的使用。● 连接的建立是经过三次握手，断开的时候四次挥手。
设计模式六大原则之：依赖倒置原则
欢迎拜读我的作品，喜欢的领域请给我留言
08-13 1002
依赖倒置原则(Dependency Inversion Principle, DIP)是面向对象设计的核心原则之一，由罗伯特·马丁(Robert C. Martin)提出，旨在降低类间的依赖度，使之更易于维护和扩展。该原则主张高层模块不应该依赖于底层模块，两者都应依赖于抽象接口。依赖倒置原则强调的是通过引入接口和抽象类来代替直接的类依赖，使得系统设计更灵活，组件间的耦合度更低。这有助于提升系统的整体复用性和扩展性。它要求程序在设计和实现时应该依赖于抽象接口，‌而不是直接依赖于具体的实现。
设计模式之禅：组合模式解析与应用
"《设计模式之禅》第21章 - 组合模式" 组合模式是一种行为设计模式，它允许你将对象组合成树形结构来表现“整体-部分”层次结构。这种模式使得客户端代码可以一致地处理单个对象和对象组合，也就是说，它在接口上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值