行为型模式

　　行为型模式：解释器模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式。

1、责任链模式

　　使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

一、责任链模式示例

from abc import ABCMeta, abstractmethod

class Handler(metaclass=ABCMeta):   # 接口：请假处理者
    @abstractmethod
    def handle_leave(self, day):
        pass

class GeneralManager(Handler):
    def handle_leave(self, day):
        if day < 10:
            print("总经理准假%d天" % day)
        else:
            print("你仍是辞职吧")

class DepartmentManager(Handler):
    def __init__(self):
        self.next = GeneralManager()
    def handle_leave(self, day):
        if day <= 5:
            print("部门经理准假%d天" % day)
        else:
            print("部门经理职权不足")
            self.next.handle_leave(day)

class ProjectDirector(Handler):
    def __init__(self):
        self.next = DepartmentManager()

    def handle_leave(self, day):
        if day <= 3:
            print("项目主管准假%d" % day)
        else:
            print("项目主管职权不足")
            self.next.handle_leave(day)

# Client
day = 4
h = ProjectDirector()
h.handle_leave(day)

　　示例以员工请假为例：每一个具体处理者都有权限去处理请求，若是处理不了沿着链发送给next。若是全都不成功，则发送个

二、责任链模式总结

角色：

• 抽象处理者（Handler）
• 具体处理者（ConcreteHandler）
• 客户端（Client）

适用场景：

• 有多个对象能够处理一个请求，哪一个对象处理由运行时决定
• 在不明确接收者的状况下，向多个对象中的一个提交一个请求

优势：

• 下降耦合度：一个对象无需知道是其余哪个对象处理其请求

2、观察者模式

　　定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，全部依赖于它的对象都获得通知并自动更新。观察者模式又称“发布——订阅”模式。

一、观察者模式示例

from abc import ABCMeta, abstractmethod

class Observer(metaclass=ABCMeta):  # 接口：抽象订阅者
    @abstractmethod
    def update(self, notice):  # notice参数是一个Notice类的对象
        pass

class Notice:   # 抽象发布者（没有抽象方法的接口，全部方法直接定义出来）
    def __init__(self):
        self.observers = []

    def attach(self, obs):
        self.observers.append(obs)

    def detach(self, obs):
        self.observers.remove(obs)

    def notify(self):   # 推送
        for obs in self.observers:  # 每一个观察者对象
            obs.update(self)  # 传入Notice对象的自己

class StaffNotice(Notice):    # 具体的发布者
    def __init__(self, company_info=None):
        super().__init__()  # 调用父类的构造函数声明observers属性
        self.__company_info = company_info  # 公司消息处理为私有对象

    @property  # 属性装饰器
    def company_info(self):  # 读
        return self.__company_info

    @company_info.setter
    def company_info(self, info):  # 写
        self.__company_info = info
        self.notify()   # 关键代码：实现赋值后自动推送

class Staff(Observer):   # 具体观察者
    def __init__(self):
        self.company_info = None   # 构造本身的消息

    def update(self, notice):
        self.company_info = notice.company_info

notice = StaffNotice("初始公司信息")   # 建立消息发布对象
s1 = Staff()   # 建立消息观察者
s2 = Staff()
notice.attach(s1)   # 发布对象绑定观察者
notice.attach(s2)
print(s1.company_info)   # None
notice.company_info = "公司今年业绩好发奖金！"   # 写入
print(s1.company_info)   # 公司今年业绩好发奖金！
print(s2.company_info)   # 公司今年业绩好发奖金！
notice.detach(s2)   # 发布对象解绑观察者
notice.company_info = "公司明天放假！"
print(s1.company_info)   # 公司明天放假！
print(s2.company_info)   # 公司今年业绩好发奖金！

　　注意装饰器实现读和写的用法。

二、观察者模式总结

角色：

• 抽象主题（Subject）——抽象发布者
• 具体主题（ConcreteSubject）——具体发布者
• 抽象观察者（Observer）
• 具体观察者（ConcreteObserver）——订阅者

适用场景：

• 当一个抽象模型有两方面，其中一个方面依赖于另外一个方面。将这二者封装在独立对象中以使它们能够各自独立地改变和复用。
• 当对一个对象的改变须要同时改变其它对象，而不知道具体有多少对象待改变。
• 当一个对象必须知道其它对象，而它又不能假定其它对象时谁。换言之，你不但愿这些对象是紧密耦合的。

优势：

• 目标和观察者之间的抽象耦合最小
• 支持广播通讯

3、策略模式

　　定义一系列的算法，把它们一个个封装起来，并使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

一、策略模式示例

from abc import ABCMeta, abstractmethod

class Strategy(metaclass=ABCMeta):  # 抽象策略（接口）：让几种策略对外表现一致
    @abstractmethod
    def execute(self, data):  # 策略执行
        pass

class FastStratege(Strategy):       # 具体策略
    def execute(self, data):
        print("用较快的策略处理%s" % data)

class SlowStratege(Strategy):       # 具体策略
    def execute(self, data):
        print("用较慢的策略处理%s" % data)

class Context:                      # 上下文类
    # 封装全部的数据和策略，(1)不让数据直接传送给高层代码;(2)封装不须要用户的关心数据（隐藏代码）
    def __init__(self, strategy, data):
        self.data = data
        self.strategy = strategy

    def set_strategy(self, strategy):
        self.strategy = strategy

    def do_strategy(self):
        self.strategy.execute(self.data)

# client
data = "[...]"
s1 = FastStratege()
s2 = SlowStratege()
context = Context(s1, data)
context.do_strategy()  # 用较快的策略处理[...]
context.set_strategy(s2)
context.do_strategy()  # 用较慢的策略处理[...]

 

二、策略模式总结

角色：

• 抽象策略（Strategy）
• 具体策略（ConcreteStrategy）
• 上下文（Context）

优势：

• 定义了一系列可重用的算法和行为
• 消除了一些条件语句（set封装好了）
• 能够提供相同行为的不一样实现

缺点：

• 客户必须了解不一样的策略（知道不一样策略的特色和优劣势）

4、模板方法模式

　　定义了一个操做中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类能够不改变一个算法的结构便可重定义该算法的某些特定步骤。

一、模板方法模式示例

from abc import ABCMeta, abstractmethod
import time

class Window(metaclass=ABCMeta):  # 桌面程序
    @abstractmethod
    def start(self):     # 原子操做（钩子操做）
        pass

    @abstractmethod
    def repaint(self):   # 原子操做（钩子操做）
        pass

    @abstractmethod
    def stop(self):      # 原子操做（钩子操做）
        pass

    def run(self):       # 模板方法（定义整个框架）
        self.start()
        while True:
            try:
                self.repaint()
                time.sleep(1)
            except KeyboardInterrupt:
                break
        self.stop()


class MyWindow(Window):
    def __init__(self, msg):
        self.msg = msg

    def start(self):
        print("窗口开始运行")

    def stop(self):
        print("窗口结束运行")

    def repaint(self):
        print(self.msg)


MyWindow("Hello....").run()
"""
窗口开始运行
Hello....
Hello....
Hello....
窗口结束运行   <------程序中止时输出
"""

 

二、模板方法模式总结

角色：

• 抽象类（AbstractClass）：定义抽象的原子操做（钩子操做）；实现一个模板方法做为算法的骨架。
• 具体类（ConcreteClass）：实现原子操做

适用场景：

• 一次性实现一个算法的不变的部分
• 各个子类中的公共行为应该被提取出来并集中到一个公共父类中以免代码重复
• 控制子类扩展