设计模式三：行为型模式

---

 

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

 

1、责任链模式：

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

角色：

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

适用场景：

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

优点：

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

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("部门经理准假%s天" % 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 = 12
h = ProjectDirector()
h.handle_leave(day)


## 
抽象处理者：Handler
具体处理者：GeneralManager， DepartmentManager， ProjectDirector

View Code

 

2、观察者模式

内容：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。观察者模式又被成为"发布-订阅"模式

角色：

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

使用场景：

1.当一个抽象模型有两方面，其中一个方面依赖于另一个方面。将这两者封装在独立对象中以使他们可以各自独立地改变和复用。

2.当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变。

3.当一个对象必须通知其他对象，而它又不能假定其他对象是谁。换言之，你不希望这些是紧密耦合的。

优点：

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

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)


class StaffNotice(Notice):      # 具体发布者
    def __init__(self, company_info=None):
        super().__init__()
        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


# client

notice = StaffNotice("初始公司信息")
s1 = Staff()
s2 = Staff()
notice.attach(s1)
notice.attach(s2)
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)

View Code

 

3、策略模式

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

角色

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

优点：

1. 定义了一系列可重用的算法和行为
2. 消除了一些条件语句
3. 可以提供相同行为的不同表现

缺点：

　　1.客户必须了解不同的策略

from abc import ABCMeta, abstractmethod

class Strategy(metaclass=ABCMeta):
    @abstractmethod
    def execute(self, data):
        pass


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


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


class Context:
    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 = FastStrategy()
s2 = SlowStrategy()

content = Context(s1, data)
content.do_strategy()
content.set_strategy(s2)
content.do_strategy()

View Code

 

4、模板方法模式

内容：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

角色：

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

使用场景：

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

from abc import ABCMeta, abstractmethod
from time import sleep


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

View Code

 

转载于:https://www.cnblogs.com/Xuuuuuu/p/10863214.html