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

    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()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

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

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

    4. 实现要素

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

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

    5. UML图

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

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    在这个 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 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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    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()
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    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();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    6.4 C++实现

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

    #include 
#include 

// 抽象组件类
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 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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    7. 练习题

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

    要求：

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

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

  • 相关阅读:
    一图说清在哪里查看阿里云已购资源包
    标签上有什么defer和async属性？＜script＞
    Swift 并发
    深入理解注意力机制（下）——缩放点积注意力及示例
    Java处理文件流传给前端接收
    HTTP 协议的基本格式和 fiddler 的简单使用
    利用碎片时间学起来20220816
    双指针--浅试
    从零开始用C语言实现图片解码播放器(有源码)
    【开发】安防监控/视频存储/视频汇聚平台EasyCVR优化播放体验的小tips
  • 原文地址：https://blog.csdn.net/guohuang/article/details/133562884