跳转至

组合模式

组合模式

组合模式（Composite Pattern）是一种结构型设计模式，它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端对单个对象和组合对象的使用具有一致性。

组合模式的特点

  1. 部分-整体结构：将对象组合成树形结构以表示部分和整体的层次结构。
  2. 一致的接口：客户端可以一致地使用单个对象和组合对象，而无需区分它们的类型。
  3. 递归组合：组合模式可以递归地组合对象，适用于需要分层次结构的场景。

组合模式的结构

  1. 组件（Component）：定义组合对象和单个对象的接口。
  2. 叶子（Leaf）：表示组合的基本元素，没有子对象。
  3. 组合（Composite）：包含子组件，可以是叶子或其他组合对象。

组合模式的Python实现

以下是组合模式在Python中的一个实现示例：

1. 定义组件接口和叶子类

from abc import ABC, abstractmethod

class Component(ABC):
    @abstractmethod
    def operation(self) -> str:
        pass

    def add(self, component: 'Component') -> None:
        pass

    def remove(self, component: 'Component') -> None:
        pass

    def is_composite(self) -> bool:
        return False

class Leaf(Component):
    def operation(self) -> str:
        return "Leaf"

2. 定义组合类

class Composite(Component):
    def __init__(self) -> None:
        self._children: List[Component] = []

    def add(self, component: Component) -> None:
        self._children.append(component)

    def remove(self, component: Component) -> None:
        self._children.remove(component)

    def is_composite(self) -> bool:
        return True

    def operation(self) -> str:
        results = []
        for child in self._children:
            results.append(child.operation())
        return f"Branch({'+'.join(results)})"

3. 客户端代码

def client_code(component: Component) -> None:
    print(f"RESULT: {component.operation()}")

def client_code2(component1: Component, component2: Component) -> None:
    if component1.is_composite():
        component1.add(component2)
    print(f"RESULT: {component1.operation()}")

if __name__ == "__main__":
    # 简单叶子对象
    simple = Leaf()
    print("Client: I've got a simple component:")
    client_code(simple)
    print("\n")

    # 复杂组合对象
    tree = Composite()
    branch1 = Composite()
    branch1.add(Leaf())
    branch1.add(Leaf())

    branch2 = Composite()
    branch2.add(Leaf())

    tree.add(branch1)
    tree.add(branch2)
    print("Client: Now I've got a composite tree:")
    client_code(tree)
    print("\n")

    # 将叶子添加到组合对象中
    print("Client: I can add a leaf to the composite tree:")
    client_code2(tree, simple)

运行结果

Client: I've got a simple component:
RESULT: Leaf

Client: Now I've got a composite tree:
RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf))

Client: I can add a leaf to the composite tree:
RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf)+Leaf)

说明

  1. 组件（Component）：定义了组合对象和叶子对象的接口，包括operation、add、remove和is_composite方法。默认实现了add、remove和is_composite方法，叶子对象和组合对象可以选择性地重载这些方法。
  2. 叶子（Leaf）：表示基本元素，没有子对象，只实现operation方法。
  3. 组合（Composite）：包含子组件，可以是叶子或其他组合对象，实现了add、remove和operation方法，operation方法递归地调用子组件的operation方法，形成树形结构。

通过组合模式，客户端可以一致地处理单个对象和组合对象，而无需区分它们的类型，从而提高系统的灵活性和可扩展性。组合模式特别适用于需要处理树形结构或分层次结构的场景，例如图形界面、文件系统等。

评论