【设计模式】- python -行为型

关于方法如何执行，如何处理。

责任链模式

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链，并沿着这条链传递该请求。直到有一个对象处理它为止。

• 抽象处理者、具体处理者、客户端

from abc  import  ABCMeta,abstractmethod

class Handler(metaclass=ABCMeta):

    @abstractmethod
    def handler_leave(self, day):
        pass

class GeneraManager(Handler):
    def handler_leave(self, day):
        if day < 10:
            print("总经理批准")
        else:
            print("不行哦")
   
class DeparmentManager(Handler):

    def __init__(self):
        self.next = GeneraManager()

    def handler_leave(self, day):
        if day <= 3:
            print("部门经理批准了")
        else:
            self.next.handler_leave(day)

class ProjectManager(Handler):
    def __init__(self):
        self.next = DeparmentManager()
   
    def handler_leave(self, day):
        if day <= 1:
            print("项目主管批准了")
        else:
            self.next.handler_leave(day)

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，其他对象都能收到通知，并自动更新。

• 抽象主题 、具体主题、抽象观察者、具体观察者

from abc import ABCMeta, abstractmethod

class Observer(metaclass=ABCMeta):
    @abstractmethod
    def update(self, 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):
        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 
    
notice = StaffNotice("初始公司信息")

s1 = Staff()
s2 = Staff() 
notice.attach(s1)
notice.attach(s2)
print(s1.company_info)
print(s2.company_info)
notice.company_info = "发奖金了"
print(s1.company_info)
print(s2.company_info)

策略模式

定义一系列算法，把它们一个个封装起来，可以互相替换，使得算法可独立于使用它的客户而变化。

• 抽象策略、具体策略、上下文

from abc import ABCMeta, abstractmethod

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

class FastStragey(Stragey):
    def execute(self, data):
        print("快速处理数据")

class SlowStragey(Stragey):
    def execute(self, data):
        print("慢慢处理数据")

class Context:
    def __init__(self, stragey, data):
        self.stragey = stragey 
        self.data = data 
    
    def set_stragey(self, stragey):
        self.stragey = stragey 
    
    def do_stragey(self):
        self.stragey.execute(self.data)

data = "fajsdkfjaksdjfasdf"
s = FastStragey()
context = Context(s, data)
context.do_stragey()
f = SlowStragey()
context.set_stragey(f)
context.do_stragey()

模板方法

定义一个操作中的算法的骨架，将具体实现延迟到子类。
子类不改变算法的结构，重定义某些特定的步骤

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

from abc import ABCMeta,abstractmethod

class Window(metaclass=ABCMeta):
    @abstractmethod
    def start(self):
        # 特定步骤，延迟到子类实现。
        pass 

    @abstractmethod
    def repaint(self):
        pass 

    @abstractmethod
    def stop(self):
        pass 

    
    def run(self):
        # 模板方法,算法骨架
        self.start()
        self.repaint()
        self.stop() 

class MyWindow(Window):
    def start(self):
        print("start...")
    
    def stop(self):
        print("stop...")

    def repaint(self):
        print("repaint...")

MyWindow().run()