Python设计模式——组合模式(Composite)

组合模式(Composite)

组合模式是用来描述的是一组相同类型的对象的关系。一个组合模式类的实例是用来组合一系列对象(通常是树型结构)，以便来描述部分和整体的关系。
优点：

• 定义了基本对象和组合对象的关系结构(一般为树)，基本对象可以被组合成复杂的组合对象，且组合对象可以进一步被组合。
• 对调用来说，基本对象和组合对象的接口相同，调用者不需要知道当前对象是基本对象还是组合对象
• 设计优良的组合关系可以方便增加对象
  角色：
• Component：为组合模型的对象声明接口，实现组合对象、基本对象的共用接口。同时，声明树形结构。
• Leaf：树形结构的叶子
• Composite： 树形结构的节点
• Client: 调用者，通过接口操作Component对象

返回 Python设计模式-outline

示例1

# Component对象，声明对外接口
class Graphic(ABC):
    @abstractmethod
    def render(self) -> None:
        raise NotImplementedError("You should implement this!")

# Composite
class CompositeGraphic(Graphic):
    def __init__(self) -> None:
        self.graphics: List[Graphic] = []

    def render(self) -> None:
        for graphic in self.graphics:
            graphic.render()

    def add(self, graphic: Graphic) -> None:
        self.graphics.append(graphic)

    def remove(self, graphic: Graphic) -> None:
        self.graphics.remove(graphic)

# leaf
class Ellipse(Graphic):
    def __init__(self, name: str) -> None:
        self.name = name

    def render(self) -> None:
        print(f"Ellipse: {self.name}")

# 调用，没有专门写Client
if __name__ == '__main__':
    # 4个叶子
    ellipse1 = Ellipse("1")
    ellipse2 = Ellipse("2")
    ellipse3 = Ellipse("3")
    ellipse4 = Ellipse("4")

    # 两个节点，各包含2个叶子
    graphic1 = CompositeGraphic()
    graphic1.add(ellipse1)
    graphic1.add(ellipse2)

    graphic2 = CompositeGraphic()    
    graphic1.add(ellipse3)
    graphic2.add(ellipse4)

    # 一个包含两个节点的节点
    graphic = CompositeGraphic()
    graphic.add(graphic1)
    graphic.add(graphic2)

    # 调用最上层节点的忌口
    graphic.render()
    # 预期输出
    # Ellipse: 1
    # Ellipse: 2
    # Ellipse: 3
    # Ellipse: 4

示例2

# Component对象，声明对外接口
class Staff(object):
    __metaclass__ = abc.ABCMeta
 
    @abc.abstractmethod
    def add_people(self, *args, **kwargs):
        pass
 
    @abc.abstractmethod
    def remove_people(self, *args, **kwargs):
        pass
 
    @abc.abstractmethod
    def work(self, *args, **kwargs):
        pass
 
# leaf 
class Teacher(Staff):
    def __init__(self, name):
        self.name = name
 
    def add_people(self):
        print('I am a regular teacher, no man at my hand')
 
    def remove_people(self):
        print('no man at my hand')
 
    def work(self):
        print('regular teacher %s start working' % self.name)
 
# composite 
class Director(Staff):
    def __init__(self, name):
        self.name = name
        self.members = []
 
    def add_people(self, teacher):
        self.members.append(teacher)
 
    def remove_people(self, teacher):
        self.members.remove(teacher)
 
    def work(self):
        print('director %s start working' % self.name)
        for member in self.members:
            member.work()
 
#client 
class Client(object):
    def __init__(self, teacher):
        self.teacher = teacher
 
    def work(self):
        self.teacher.work()


if __name__ == '__main__':
    # 初级教师
    j1 = Teacher('Junier 1')
    j2 = Teacher('Junier 2')
    # 中级教师
    m = Director('Mediate')
    m.add_people(j1)
    m.add_people(j2)
    # 高级教师
    s = Director('Senior')
    s.add_people(m)
    
    # 调用者
    client = Client(s)
    client.work()
    # 预期输出
    # director s start working
    # director m start working
    # regular teacher j1 start working
    # regular teacher j2 start working

    client.teacher = m
    client.work()
    # 预期输出
    # director m start working
    # regular teacher j1 start working
    # regular teacher j2 start working

    client.teacher = j1
    client.work()
    # 预期输出    
    # regular teacher j1 start working

ref

https://blog.csdn.net/hbuxiaofei/article/details/106875759