Python实现策略模式、观察者模式和责任链模式

2024年 6月 4日 70.7k 0

今天我们将介绍三种行为型设计模式:策略模式、观察者模式和责任链模式。

Python实现策略模式、观察者模式和责任链模式-1

1.策略模式

策略模式是一种行为设计模式,它允许在运行时选择算法的行为。它将算法封装在独立的策略类中,使得它们可以互相替换,而不会影响到客户端代码。在Python中,我们可以使用函数或者类来实现策略模式。

(1) 策略模式的结构

策略模式的核心是定义一个策略接口,所有的具体策略都要实现这个接口。然后,我们可以在客户端代码中使用策略对象,而不需要关心具体的实现细节。

以下是策略模式的基本结构:

# 策略接口
class Strategy:
    def do_operation(self):
        pass

# 具体策略类
class ConcreteStrategyA(Strategy):
    def do_operation(self):
        print("执行策略A的操作")

class ConcreteStrategyB(Strategy):
    def do_operation(self):
        print("执行策略B的操作")

# 上下文类
class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_strategy(self):
        self.strategy.do_operation()

# 客户端代码
if __name__ == "__main__":
    strategy_a = ConcreteStrategyA()
    strategy_b = ConcreteStrategyB()

    context = Context(strategy_a)
    context.execute_strategy()

    context.strategy = strategy_b
    context.execute_strategy()

(2) 策略模式的应用场景

策略模式适用于以下场景:

  • 当一个系统有多个算法,并且需要在运行时根据不同情况选择其中一个算法时。
  • 当一个类有多个行为,并且这些行为可以通过继承来扩展时。
  • 当一个类的行为在运行时可以动态改变时。

(3) 策略模式的优点

  • 策略模式将算法的实现与使用算法的客户端代码分离,使得它们可以独立地变化。
  • 策略模式遵循开闭原则,新的策略可以很容易地添加到系统中,而不会影响到原有的代码。

(4) 策略模式的缺点

  • 策略模式增加了系统中类的数量,增加了代码的复杂度。
  • 客户端需要了解所有的策略类,才能选择合适的策略。

2.观察者模式

它定义了一种一对多的依赖关系,让多个观察者对象同时监听一个主题对象。当主题对象的状态发生变化时,它会通知所有的观察者对象,使得它们能够自动更新。

(1) 观察者模式的结构

观察者模式的核心是主题对象和观察者对象之间的关系。主题对象维护一个观察者列表,当主题对象的状态发生变化时,它会遍历观察者列表,通知每个观察者对象进行更新。

以下是观察者模式的基本结构:

# 主题接口
class Subject:
    def attach(self, observer):
        pass

    def detach(self, observer):
        pass

    def notify(self):
        pass

# 具体主题类
class ConcreteSubject(Subject):
    def __init__(self):
        self.observers = []

    def attach(self, observer):
        self.observers.append(observer)

    def detach(self, observer):
        self.observers.remove(observer)

    def notify(self):
        for observer in self.observers:
            observer.update()

# 观察者接口
class Observer:
    def update(self):
        pass

# 具体观察者类
class ConcreteObserverA(Observer):
    def update(self):
        print("观察者A收到通知")

class ConcreteObserverB(Observer):
    def update(self):
        print("观察者B收到通知")

# 客户端代码
if __name__ == "__main__":
    subject = ConcreteSubject()
    observer_a = ConcreteObserverA()
    observer_b = ConcreteObserverB()

    subject.attach(observer_a)
    subject.attach(observer_b)

    subject.notify()

    subject.detach(observer_b)

    subject.notify()

(2) 观察者模式的应用场景

观察者模式适用于以下场景:

  • 当一个对象的改变需要同时改变其他对象时。
  • 当一个对象的改变需要通知一组对象时。
  • 当一个对象的改变需要让其他对象自动更新时。

(3) 观察者模式的优点

  • 观察者模式将主题对象和观察者对象解耦,使得它们可以独立地变化。
  • 观察者模式遵循开闭原则,新的观察者可以很容易地添加到系统中,而不会影响到原有的代码。

(4) 观察者模式的缺点

  • 观察者模式可能会导致系统中观察者对象过多,增加了代码的复杂度。
  • 观察者模式中,观察者对象与主题对象之间存在循环依赖的关系,可能会导致循环引用的问题。

3.责任链模式

它将请求的发送者和接收者解耦,使得多个对象都有机会处理请求。将这些对象串成一条链,并沿着这条链传递请求,直到有一个对象能够处理它为止。

(1) 责任链模式的结构

责任链模式的核心是责任链对象和处理对象之间的关系。责任链对象维护一个处理对象列表,当收到请求时,它会遍历处理对象列表,直到找到能够处理请求的对象。

以下是责任链模式的基本结构:

# 处理对象接口
class Handler:
    def set_successor(self, successor):
        pass

    def handle_request(self, request):
        pass

# 具体处理对象类
class ConcreteHandlerA(Handler):
    def __init__(self):
        self.successor = None

    def set_successor(self, successor):
        self.successor = successor

    def handle_request(self, request):
        if request == "A":
            print("处理对象A处理请求")
        elif self.successor is not None:
            self.successor.handle_request(request)

class ConcreteHandlerB(Handler):
    def __init__(self):
        self.successor = None

    def set_successor(self, successor):
        self.successor = successor

    def handle_request(self, request):
        if request == "B":
            print("处理对象B处理请求")
        elif self.successor is not None:
            self.successor.handle_request(request)

# 客户端代码
if __name__ == "__main__":
    handler_a = ConcreteHandlerA()
    handler_b = ConcreteHandlerB()

    handler_a.set_successor(handler_b)

    handler_a.handle_request("A")
    handler_a.handle_request("B")
    handler_a.handle_request("C")

(2) 责任链模式的应用场景

责任链模式适用于以下场景:

  • 多个对象可以处理同一个请求,但具体由哪个对象处理是在运行时动态决定的。
  • 需要将请求的发送者和接收者解耦,使得多个对象都有机会处理请求。

(3) 责任链模式的优点

  • 责任链模式将请求的发送者和接收者解耦,使得它们可以独立地变化。
  • 责任链模式遵循开闭原则,新的处理对象可以很容易地添加到系统中,而不会影响到原有的代码。

(4) 责任链模式的缺点

  • 责任链模式中,请求可能会在责任链上被多次处理,可能会导致性能问题。

相关文章

JavaScript2024新功能:Object.groupBy、正则表达式v标志
PHP trim 函数对多字节字符的使用和限制
新函数 json_validate() 、randomizer 类扩展…20 个PHP 8.3 新特性全面解析
使用HTMX为WordPress增效:如何在不使用复杂框架的情况下增强平台功能
为React 19做准备:WordPress 6.6用户指南
如何删除WordPress中的所有评论

发布评论