设计模式——10. 组合模式

已于 2023-10-08 23:05:23 修改
阅读量872 收藏 1
点赞数
分类专栏： 设计模式大全 文章标签： 设计模式 组合模式 python java golang c++ javascript
于 2023-10-05 19:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133562884
版权

1. 说明

组合模式是一种结构型设计模式，用于将对象组合成树状结构以表示“部分-整体”的层次结构。它允许客户端以一致的方式处理单个对象和组合对象（包含多个对象的容器），使得客户端无需关心它们之间的差异。

组合模式通常涉及两种主要角色：

  1. 叶子节点（Leaf）：这是组合中的基本对象，它不能包含其他对象。叶子节点执行特定操作。
  2. 组合节点（Composite）：这是包含子对象的复杂对象。组合节点通常执行某种操作，然后将操作传递给其子节点。

组合模式的关键思想是将叶子节点和组合节点都视为相同类型的对象，它们都实现了相同的接口，从而客户端可以一致地处理它们。

组合模式的主要优点包括：

  1. 简化客户端代码：客户端不需要区分叶子节点和组合节点，可以统一处理。
  2. 支持嵌套结构：可以轻松创建包含多层次嵌套的树状结构。
  3. 提供了高扩展性：可以轻松地添加新的叶子节点或组合节点，而不会影响现有代码。

总之，组合模式允许你创建具有灵活结构的对象树，从而更容易地管理和操作对象的层次结构。

2. 使用的场景

组合模式通常适用于以下场景：

  1. 层次结构对象：当你需要表示对象的层次结构，其中对象可以是单个元素或包含其他对象的容器时，组合模式非常有用。例如，文件系统中的文件和文件夹，图形用户界面中的窗口和控件，组织结构中的部门和员工等。
  2. 统一处理：当你希望客户端代码能够统一处理单个对象和组合对象时，组合模式是一种有用的方式。客户端不需要关心它们处理的是叶子节点还是组合节点。
  3. 递归结构：当对象之间存在递归关系，且你希望以一种统一的方式遍历和操作整个结构时，组合模式非常适合。例如，在解析树、XML文档、目录结构等场景中。
  4. 添加新组件类型：当你需要在不修改现有代码的情况下添加新的组件类型时，组合模式是一种非常灵活的设计。你只需要创建新的叶子节点或组合节点，并确保它们实现了相同的接口。
  5. 操作整体和部分：当你需要对整体和部分进行一致性操作时，组合模式非常有用。例如，对于图形界面中的窗口和其中的所有控件，你可以同时执行操作，而不需要单独处理每个控件。

总之，组合模式适用于那些具有层次结构、需要统一处理、具有递归关系或需要支持动态添加新组件类型的情况。它有助于简化复杂结构的管理和操作，提高代码的可维护性和扩展性。

3. 应用例子

以下是一个使用 Python 实现的组合模式示例，模拟了文件系统的层次结构：

from abc import ABC, abstractmethod

# 抽象组件类
class FileSystemComponent(ABC):
    @abstractmethod
    def display(self):
        pass

# 叶子节点类 - 文件
class File(FileSystemComponent):
    def __init__(self, name):
        self.name = name

    def display(self):
        print(f"File: {self.name}")

# 组合节点类 - 文件夹
class Folder(FileSystemComponent):
    def __init__(self, name):
        self.name = name
        self.children = []

    def add(self, component):
        self.children.append(component)

    def remove(self, component):
        self.children.remove(component)

    def display(self):
        print(f"Folder: {self.name}")
        for child in self.children:
            child.display()

# 客户端代码
if __name__ == "__main__":
    root = Folder("Root")
    file1 = File("File 1")
    file2 = File("File 2")
    folder1 = Folder("Folder 1")
    file3 = File("File 3")

    root.add(file1)
    root.add(file2)
    root.add(folder1)
    folder1.add(file3)

    root.display()

在这个示例中，我们有两种类型的节点：File 表示叶子节点（文件），Folder 表示组合节点（文件夹）。它们都实现了 FileSystemComponent 抽象类，其中包括 display 方法以显示节点的信息。

客户端代码创建了一个包含文件和文件夹的层次结构，并使用 display 方法遍历并显示整个文件系统结构。这个示例演示了组合模式的核心概念，即叶子节点和组合节点具有相同的接口，并且客户端可以一致地处理它们。

4. 实现要素

组合模式的主要要素包括以下部分：

  1. Component（组件）：这是一个抽象类或接口，定义了叶子节点和组合节点的公共接口。它通常包括了一些操作，例如操作叶子节点或组合节点的方法。
  2. Leaf（叶子节点）：这是组合中的基本对象，它实现了 Component 接口。叶子节点不能包含其他对象，通常执行具体的操作。
  3. Composite（组合节点）：这是包含子对象的复杂对象，也实现了 Component 接口。组合节点执行某些操作，然后将操作传递给其子节点。组合节点可以包含叶子节点或其他组合节点，从而创建层次结构。

5. UML图

下面是组合模式的简化 UML 类图：

         +-------------------------+
         |        Component        |
         +-------------------------+
         | + operation()           |
         +-------------------------+
                 /       \
                /         \
               /           \
              /             \
 +----------------+   +----------------+
 |     Leaf       |   |    Composite   |
 +----------------+   +----------------+
 |                |   |                |
 +----------------+   +----------------+

在这个 UML 类图中，Component 定义了操作，Leaf 和 Composite 都实现了 Component 接口。Leaf 表示叶子节点，Composite 表示组合节点。
组合模式的关键思想是使叶子节点和组合节点具有相同的接口，以便客户端可以一致地处理它们。这种统一性使得组合模式能够处理具有层次结构的对象，而不需要客户端关心对象的类型。

6. Java/golang/javascrip/C++ 等语言实现方式

6.1 Java实现

上述例子用Java语言实现示例如下：

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

// 抽象组件类
abstract class FileSystemComponent {
    abstract void display();
}

// 叶子节点类 - 文件
class File extends FileSystemComponent {
    private String name;

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

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

// 组合节点类 - 文件夹
class Folder extends FileSystemComponent {
    private String name;
    private List<FileSystemComponent> children = new ArrayList<>();

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

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

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

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

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Folder root = new Folder("Root");
        File file1 = new File("File 1");
        File file2 = new File("File 2");
        Folder folder1 = new Folder("Folder 1");
        File file3 = new File("File 3");

        root.add(file1);
        root.add(file2);
        root.add(folder1);
        folder1.add(file3);

        root.display();
    }
}

6.2 Golang实现

上述例子用golang实现示例如下：

package main

import "fmt"

// 抽象组件接口
type FileSystemComponent interface {
    Display()
}

// 叶子节点类 - 文件
type File struct {
    name string
}

func NewFile(name string) *File {
    return &File{name}
}

func (f *File) Display() {
    fmt.Printf("File: %s\n", f.name)
}

// 组合节点类 - 文件夹
type Folder struct {
    name     string
    children []FileSystemComponent
}

func NewFolder(name string) *Folder {
    return &Folder{name, make([]FileSystemComponent, 0)}
}

func (d *Folder) Add(component FileSystemComponent) {
    d.children = append(d.children, component)
}

func (d *Folder) Remove(component FileSystemComponent) {
    for i, c := range d.children {
        if c == component {
            d.children = append(d.children[:i], d.children[i+1:]...)
            return
        }
    }
}

func (d *Folder) Display() {
    fmt.Printf("Folder: %s\n", d.name)
    for _, c := range d.children {
        c.Display()
    }
}

func main() {
    root := NewFolder("Root")
    file1 := NewFile("File 1")
    file2 := NewFile("File 2")
    folder1 := NewFolder("Folder 1")
    file3 := NewFile("File 3")

    root.Add(file1)
    root.Add(file2)
    root.Add(folder1)
    folder1.Add(file3)

    root.Display()
}

6.3 Javascript实现

上述例子用javascript实现示例如下：

// 抽象组件类
class FileSystemComponent {
    display() {}
}

// 叶子节点类 - 文件
class File extends FileSystemComponent {
    constructor(name) {
        super();
        this.name = name;
    }

    display() {
        console.log(`File: ${this.name}`);
    }
}

// 组合节点类 - 文件夹
class Folder extends FileSystemComponent {
    constructor(name) {
        super();
        this.name = name;
        this.children = [];
    }

    add(component) {
        this.children.push(component);
    }

    remove(component) {
        this.children = this.children.filter(child => child !== component);
    }

    display() {
        console.log(`Folder: ${this.name}`);
        for (const child of this.children) {
            child.display();
        }
    }
}

// 客户端代码
const root = new Folder("Root");
const file1 = new File("File 1");
const file2 = new File("File 2");
const folder1 = new Folder("Folder 1");
const file3 = new File("File 3");

root.add(file1);
root.add(file2);
root.add(folder1);
folder1.add(file3);

root.display();

6.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <vector>

// 抽象组件类
class FileSystemComponent {
public:
    virtual void display() = 0;
};

// 叶子节点类 - 文件
class File : public FileSystemComponent {
private:
    std::string name;

public:
    File(const std::string& name) : name(name) {}

    void display() override {
        std::cout << "File: " << name << std::endl;
    }
};

// 组合节点类 - 文件夹
class Folder : public FileSystemComponent {
private:
    std::string name;
    std::vector<FileSystemComponent*> children;

public:
    Folder(const std::string& name) : name(name) {}

    void add(FileSystemComponent* component) {
        children.push_back(component);
    }

    void remove(FileSystemComponent* component) {
        for (auto it = children.begin(); it != children.end(); ++it) {
            if (*it == component) {
                children.erase(it);
                break;
            }
        }
    }

    void display() override {
        std::cout << "Folder: " << name << std::endl;
        for (auto child : children) {
            child->display();
        }
    }
};

int main() {
    Folder root("Root");
    File file1("File 1");
    File file2("File 2");
    Folder folder1("Folder 1");
    File file3("File 3");

    root.add(&file1);
    root.add(&file2);
    root.add(&folder1);
    folder1.add(&file3);

    root.display();

    return 0;
}

7. 练习题

在一个文件系统中，有文件和文件夹两种类型的元素。文件是叶子节点，而文件夹是组合节点。使用组合模式来建模这个文件系统。

要求：

  1. 创建一个抽象组件类 FileSystemComponent，其中包括一个抽象方法 display()。
  2. 创建一个叶子节点类 File，它继承自 FileSystemComponent，包括一个属性 name 表示文件名，并实现 display() 方法以显示文件名。
  3. 创建一个组合节点类 Folder，它继承自 FileSystemComponent，包括一个属性 name 表示文件夹名，以及一个保存子元素的容器，实现 add() 和 remove() 方法来添加和移除子元素，并实现 display() 方法以显示文件夹名以及其中的子元素。
  4. 在客户端代码中创建一个文件系统层次结构，包括文件和文件夹，然后使用 display() 方法显示整个文件系统结构。

你可以使用 C++、Java、Python 或任何其他编程语言来实现这个练习。
你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
专栏目录
设计模式——JAVA.docx
04-03
### JAVA设计模式总结之23种设计模式及六大原则 #### 一、设计模式之六大原则 ##### 总原则：开闭原则（Open Close Principle） 开闭原则是设计模式中最核心的原则之一，它强调的是软件实体（类、模块、函数等）...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
设计模式——组合模式
01-07
由于不同地区存在着上下级关系，且会拥有多平级组合，如果采用每个组合主一个类，这样需要创建的类特别多，此时可使用组合模式，如下图： 上图左边可转为右边的递归关系，其原理是把一组相似的对象当作一个单一的...
行为设计模式 -观察者模式- JAVA
智的博客
10-03 1580
观察者模式是一种对象行为模式。又被称为发布-订阅（Publish/Subscribe）模式， 它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。观察者模式不仅被广泛应用于软件界面元素之间的交互，在业务对象之间的交互、权限管理等方面也有广泛的应用。这个模式在日常开发中很常见，比如a服务想要b服务磁盘满的时候通知它，那么它只需要把自己的。
LabVIEW提高开发效率技巧----调度器设计模式
bjcyck的博客
10-04 1227
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
设计模式之命令模式
一个老Java开发的自白
10-01 1218
命令模式是一种非常强大和灵活的设计模式，它将请求封装为对象，从而使得请求的发送者和接收者解耦。命令模式不仅支持基本的执行操作，还支持撤销、重做、事务性操作、延迟执行和异步执行等高级特性。通过合理地使用命令模式及其扩展和变体，可以大大简化代码的结构和逻辑，提高系统的可扩展性和可维护性。 在实际应用中，我们应该根据具体的需求和场景来选择合适的命令模式实现方式，并结合其他设计模式和技术来构建更加复杂和高效的系统。
设计模式-适配器模式
ZSS1753936255的博客
10-02 454
这段代码就是在适配器Adapter中关联了适配器适配器母接口Speker. 在适配器中的translate中实现了 speaker.speak()方法。首先：如何调用被适配的对象呢？可以通过 关联或者继承 适配器来实现。（1：这段代码是通过是通过继承来实现的，也达到了接口转换的目的）适配器模式：将一类的接口转换成满足用户需求的另一种接口。是的不相容的接口得以共同工作。2:通过对象关联的方法来实现适配器，就是上述的UML类图保持一致。
设计模式-模版方法模式
ZSS1753936255的博客
10-04 508
模版方法模式(Template Method):定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些定义步骤。抽象类：负责实现一个算法的骨架，他是由一个final修饰的模版方法和若干个基本方法组成的。
【设计模式-职责链】
严文文 Chris
09-30 774
职责链模式是一种行为设计模式，**它通过将请求发送给链上的多个处理者来避免请求发送者与处理者之间的紧密耦合。每个处理者可以选择处理请求或将其传递给链中的下一个处理者。**这样，可以将处理请求的责任链式组织，从而实现更灵活的请求处理机制。
设计模式之访问者
qq_74811378的博客
10-02 1205
（Visitor） 是一种行为设计模式， 它能将算法与其所作用的对象隔离开来。适用场景代码如下：问题：做一款生成冰激凌和雪糕的程序，要求可以扩展新的口味，并且可以扩展新的包装方式。解决方案：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
设计模式-访问者模式
ZSS1753936255的博客
10-04 367
访问者模式（Visitor）:表示一个作用于某对象结构中的各元素的操作，使得在不改变个元素的类的前提下定义作用于这些元素的新操作。
设计模式-职责链模式
ZSS1753936255的博客
10-04 359
在职责链模式中，使得每一个对象都有可能来处理请求，而将这些多个对象 串一条链 来传递处理请求。只有最后最后一个对象可以完全处理这个请求。即最后一个对象也就是 链尾。从而也就实现了 请求的接受者和 发送者之间的解耦。职责链模式（Chain of Responsibility）:通过给多个对象请求处理的机会，减少请求的发送者和接受者之间的耦合。将这些对象链接起来，在链中传递请求，知道有一个对象处理这个请求。职责链模式就是把多个处理者连起来形成一个链条，实现解耦。
设计模式-命令模式
ZSS1753936255的博客
10-04 398
命令模式和职责链模式的一个相同点都是 将发送者和接收者完全的解耦。发送者和接收者没有直接的联系，发送者只需要知道如何发送命令即可，不需要知道命令是否成功。根据上面的这单代码中可以分析的出：命令发出者，发出一个具体的命令，而具体的命令中 关联了命令接受者，告诉接受者应该怎么做，就是让接受者去执行命令。命令模式（Command）：将一个请求封装成一个对象，从而可用不同的请求对客户进行参数化，将请求排队或者记录请求日志，支持可撤销的操作。
设计模式-策略模式
m0_45164511的博客
10-06 448
【代码】设计模式-策略模式java。
设计模式-桥接模式
ZSS1753936255的博客
10-03 1031
手机按照品牌分可以分为华为、小米、oppo、vivo等m个品牌，如果这些手机按照内存分又可以分为4G、6G、8G等n个内存。通过继承来实现的话，则需要 m*n个实现类（小米4g,小米6g,小米8g,华为4g,华为6g,华为8g，vivo4g,vivo6g,vivo8g,oppo4g,oppo6g,oppo8g）。减低了系统的复杂度。而Brand依赖了Memory部门，想当是这部分的依赖，就是一座桥。桥接模式将继承关系转化成关联关系，封装了变化，完成了解耦，减少了系统中类的数量，也减少了代码量。
sidecar 和 插件的区别
最新发布
喝醉酒的小白
10-07 226
Sidecar 模式可以提高容器的可维护性、可扩展性和安全性，同时也可以减少容器间的耦合度。插件通常是在应用程序运行时动态加载的，可以添加新的功能、修改现有的功能或者替换现有的功能。Sidecar 是一种设计模式，用于将辅助功能与主应用程序分离，而插件是一种软件组件，用于扩展应用程序的功能。虽然它们都可以提高应用程序的可维护性和可扩展性，但它们的实现方式和用途是不同的。Sidecar 和插件是两个不同的概念，尽管它们都可以提高应用程序的可维护性和可扩展性，但它们的实现方式和用途是不同的。
设计模式-工厂模式
ZSS1753936255的博客
10-02 663
工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。由此发现：都是先创建工厂，然后在使用工厂实例获取产品。此时只有一个工厂，那么只能创建一类型的产品。当系统中加入新产品时，除了需要提供新的产品类之外，还要提供与其对应的具体工厂类。而工厂子类则负责生成具体的产品对象，即通过不同的工厂子类来创建不同的产品对象。
"设计模式——可复用面向对象软件的基础
2001年6月25日，冯铁发表了《设计模式——可复用面向对象软件的基础》，详细介绍了四种设计模式。这四种设计模式分别是创建型模式、结构型模式、行为型模式和并发模式。每种设计模式都有其固定的模式名、问题、解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值