行爲型模式

時間 2019-11-16

標籤行爲模式简体版

原文原文鏈接

　　行爲型模式：解釋器模式、責任鏈模式、命令模式、迭代器模式、中介者模式、備忘錄模式、觀察者模式、狀態模式、策略模式、訪問者模式、模板方法模式。算法

1、責任鏈模式

　　使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止。app

一、責任鏈模式示例

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）

適用場景：spa

有多個對象能夠處理一個請求，哪一個對象處理由運行時決定
在不明確接收者的狀況下，向多個對象中的一個提交一個請求

優勢：code

下降耦合度：一個對象無需知道是其餘哪個對象處理其請求

2、觀察者模式

　　定義對象間的一種一對多的依賴關係，當一個對象的狀態發生改變時，全部依賴於它的對象都獲得通知並自動更新。觀察者模式又稱「發佈——訂閱」模式。server

一、觀察者模式示例

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)   # 公司今年業績好發獎金！

　　注意裝飾器實現讀和寫的用法。對象

二、觀察者模式總結

角色：blog

抽象主題（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....
窗口結束運行   <------程序中止時輸出
"""