sjms-4 行爲型模式

行爲型模式

責任鏈模式


內容:使多個對象都有機會處理請求,從而避免請求的發送者和接收者之間的耦合關係。
將這些對象連成一條鏈,並沿着這條鏈傳遞該請求,直到有一個對象處理它爲止。
角色:
抽象處理者(Handler)
具體處理者(ConcreteHandler)
客戶端(Client)python

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)


day = 12
h = ProjectDirector()
h.handle_leave(day)

  


適用場景:
有多個對象能夠處理一個請求,哪一個對象處理由運行時決定
在不明確接收者的狀況下,向多個對象中的一個提交一個請求
優勢:
下降耦合度:一個對象無需知道是其餘哪個對象處理其請求算法

 

觀察者模式

內容:定義對象間的一種一對多的依賴關係,當一個對象的狀態發生改變時, 全部依賴於它的對象都獲得
通知並被自動更新。觀察者模式又稱「發佈-訂閱」模式
角色:
抽象主題(Subject)
具體主題(ConcreteSubject)——發佈者
抽象觀察者(Observer)
具體觀察者(ConcreteObserver)——訂閱者app

 

from abc import ABCMeta, abstractmethod

class Observer(metaclass=ABCMeta): # 抽象訂閱者
    @abstractmethod
    def update(self, notice): # 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)



"""
公司今年業績很是好,給你們發獎金!!!
公司今年業績很是好,給你們發獎金!!!
公司明天放假!!!
公司今年業績很是好,給你們發獎金!!!

"""

  


適用場景:
當一個抽象模型有兩方面,其中一個方面依賴於另外一個方面。將這二者封裝在獨立對象中以使它們能夠各自獨立地改變和
複用。
當對一個對象的改變須要同時改變其它對象,而不知道具體有多少對象有待改變。
當一個對象必須通知其它對象,而它又不能假定其它對象是誰。換言之,你不但願這些對象是緊密耦合的。
優勢:
目標和觀察者之間的抽象耦合最小
支持廣播通訊server

 

 

 

 

策略模式

內容:定義一系列的算法,把它們一個個封裝起來,而且使它們可相互替換。本模式使
得算法可獨立於使用它的客戶而變化。
角色:
抽象策略(Strategy)
具體策略(ConcreteStrategy)
上下文(Context)對象

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)


data = "[...]"
s1 = FastStrategy()
s2 = SlowStrategy()
context = Context(s1, data)
context.do_strategy()
context.set_strategy(s2)
context.do_strategy()

  


優勢:
定義了一系列可重用的算法和行爲
消除了一些條件語句
能夠提供相同行爲的不一樣實現
缺點:
客戶必須瞭解不一樣的策略blog

 

 

模板方法模式

 

內容:定義一個操做中的算法的骨架,而將一些步驟延遲到子類中。模板方法
使得子類能夠不改變一個算法的結構便可重定義該算法的某些特定步驟。
角色:
抽象類(AbstractClass):定義抽象的原子操做(鉤子操做);實現一個模
板方法做爲算法的骨架。
具體類(ConcreteClass):實現原子操做rem

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

  


適用場景:
一次性實現一個算法的不變的部分
各個子類中的公共行爲應該被提取出來並集中到一個公共父類中以
避免代碼重複
控制子類擴展it

相關文章
相關標籤/搜索