設計模式三：行爲型模式

---

 

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

 

一、責任鏈模式：

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

角色：

• 抽象處理者（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

 

二、觀察者模式

內容：定義對象間的一種一對多的依賴關係，當一個對象的狀態發生改變時，全部依賴於它的對象都獲得通知並被自動更新。觀察者模式又被成爲"發佈-訂閱"模式

角色：

• 抽象主題（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

 

三、策略模式

內容：定義一系列的算法，把他們一個個封裝起來，而且使它們可互相替換。本模式使得算法可獨立於使用它的客戶而變化

角色

• 抽象策略（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

 

四、模板方法模式

內容：定義一個操做中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類能夠不改變一個算法的結構便可重定義該算法的某些特定步驟。

角色：

• 抽象類（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