5.行為型模式

ThankCAT發表於2024-03-26
模式

@

目錄
  • 1. 責任鏈模式
  • 2. 觀察者模式
  • 3. 策略模式
  • 4. 模板方法模式

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 <= 30:
            print('總經理准假%d' % day)
        else:
            print('可以辭職了！')

# 具體的處理者
class DepartmentManager(Handler):
    def __init__(self):
        self.next = GeneralManager()

    def handle_leave(self, day):
        if day <= 7:
            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)

day = 20
p = ProjectDirector()
p.handle_leave(day)
"""
專案主管職權不足
部門經理職權不足
總經理准假20
"""

使用場景：有多個物件可以處理一個請求，哪個物件處理由執行時決定；在不明確接收者的情況下，向多個物件中的一個提交一個請求。優點是降低耦合度，一個物件無需知道是其它哪一個物件處理其請求。

2. 觀察者模式

觀察者模式應用比較廣泛，又被稱為“釋出-訂閱”模式。它用來定義物件間一種一對多的依賴關係，當一個物件的狀態發生變化時，所有依賴它的物件都得到通知並被自動更新。觀察者模式的角色有：抽象主題、具體主題（釋出者）、抽象觀察者和具體觀察者（訂閱者）。

from abc import ABCMeta, abstractmethod

# 抽象的訂閱者
class Observer(metaclass=ABCMeta):
    @abstractmethod
    def update(self, notice):
        """
        :param notice: Notice類的物件
        :return:
        """
        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):
        """
        推送
        :return:
        """
        for obs in self.observers:
            obs.update(self)

# 具體的釋出者
class StaffNotice(Notice):
    def __init__(self, company_info):
        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

staff_notice = StaffNotice('初始化公司資訊')
staff1 = Staff()
staff2 = Staff()
staff_notice.attach(staff1)
staff_notice.attach(staff2)
# print(staff1.company_info) None
# print(staff2.company_info) None
staff_notice.company_info = '假期放假通知！'
print(staff1.company_info)
print(staff2.company_info)
staff_notice.detach(staff2)
staff_notice.company_info = '明天開會！'
print(staff1.company_info)
print(staff2.company_info)
"""
假期放假通知！
假期放假通知！
明天開會！
假期放假通知！
"""

使用場景：當一個抽象模型有兩個方面，其中一個方面依賴另一個方面。將這兩者封裝在獨立物件中以使它們可以各自獨立地改變和複用；當對一個物件的改變需要同時改變其它物件，而不知道具體有多少物件待改變；當一個物件必須通知其它物件，而它又不能假定其它物件是誰。換言之，你不希望這些物件是緊耦合的。優點：目標和觀察者之間的抽象耦合最小；支援廣播通訊。

3. 策略模式

定義一個個演算法，把它們封裝起來，並且使它們可以相互替換。本模式使得演算法可獨立於使用它的客戶而變化。角色有：抽象策略、具體策略和上下文。

from abc import abstractmethod, ABCMeta
from datetime import datetime

# 抽象策略
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
        # 可以定義使用者不知道的東西
        self.date = datetime.now()

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

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

data = "Hello!"
# 使用較快的策略處理
fast_strategy = FastStrategy()
context = Context(fast_strategy, data)
context.do_strategy()
# 使用較慢的策略處理
slow_strategy = SlowStrategy()
context = Context(slow_strategy, data)
context.do_strategy()
"""
使用較快的策略處理Hello!
使用較慢的策略處理Hello!
"""

優點：定義了一些列可重用的演算法和行為；消除了一些條件語句；可以提供相同行為的不同實現；缺點：客戶必須瞭解不同的策略。

4. 模板方法模式

內容：定義一個操作中的演算法骨架，將一些步驟延遲到子類中。模板方法使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。使用模板方法，需要用到兩種角色，分別是抽象類和具體類。抽象類的作用是是定義抽象類（鉤子操作），實現一個模板方法作為演算法的骨架。具體類的作用實現原子操作。

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):
        """
        模板方法(具體方法)，這個大邏輯就不需要自己寫了
        :return:
        """
        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()

模板方法適用的場景：一次性實現一個演算法的不變部分，各個子類中的公共行為應該被提取出來並集中到一個公共父類中以避免程式碼重複；控制子類擴充套件。

相關文章