今天介绍三种行为型设计模式:命令模式、中介者模式和解释器模式。
1.命令模式
它将请求封装成一个对象,从而使得可以用不同的请求对客户进行参数化。命令模式也支持撤销操作。
(1) 命令模式的结构
命令模式的核心是命令对象和接收者对象之间的关系。命令对象封装了一个特定的请求,包含了执行该请求的方法。接收者对象负责实际执行请求。
以下是命令模式的基本结构:
# 命令对象接口
class Command:
def execute(self):
pass
def undo(self):
pass
# 具体命令对象类
class ConcreteCommandA(Command):
def __init__(self, receiver):
self.receiver = receiver
def execute(self):
self.receiver.action_a()
def undo(self):
self.receiver.undo_action_a()
class ConcreteCommandB(Command):
def __init__(self, receiver):
self.receiver = receiver
def execute(self):
self.receiver.action_b()
def undo(self):
self.receiver.undo_action_b()
# 接收者对象类
class Receiver:
def action_a(self):
print("接收者执行动作A")
def action_b(self):
print("接收者执行动作B")
def undo_action_a(self):
print("接收者撤销动作A")
def undo_action_b(self):
print("接收者撤销动作B")
# 客户端代码
if __name__ == "__main__":
receiver = Receiver()
command_a = ConcreteCommandA(receiver)
command_b = ConcreteCommandB(receiver)
invoker = Invoker()
invoker.set_command(command_a)
invoker.execute_command()
invoker.set_command(command_b)
invoker.execute_command()
(2) 命令模式的应用场景
命令模式适用于以下场景:
- 需要将请求的发送者和接收者解耦,使得它们可以独立地变化。
- 需要支持撤销操作。
(3) 命令模式的优点
- 命令模式将请求的发送者和接收者解耦,使得它们可以独立地变化。
- 命令模式支持撤销操作。
- 命令模式遵循开闭原则,新的命令对象可以很容易地添加到系统中,而不会影响到原有的代码。
(4) 命令模式的缺点
- 命令模式中,命令对象和接收者对象之间存在循环依赖的关系,可能会导致循环引用的问题。
2.中介者模式
它通过封装一系列对象之间的交互,将对象之间的耦合度降低到最低。中介者模式将对象之间的交互转移给中介者对象,从而使得对象之间不再直接相互引用。
(1) 中介者模式的结构
中介者模式的核心是中介者对象,它封装了一系列对象之间的交互逻辑。中介者对象通常包含一个或多个接口,用于与其他对象进行通信。
以下是中介者模式的基本结构:
# 中介者接口
class Mediator:
def send(self, message, colleague):
pass
# 同事类接口
class Colleague:
def set_mediator(self, mediator):
pass
def send(self, message):
pass
def receive(self, message):
pass
# 具体中介者类
class ConcreteMediator(Mediator):
def __init__(self):
self.colleague_a = None
self.colleague_b = None
def set_colleague_a(self, colleague_a):
self.colleague_a = colleague_a
def set_colleague_b(self, colleague_b):
self.colleague_b = colleague_b
def send(self, message, colleague):
if colleague == self.colleague_a:
self.colleague_b.receive(message)
elif colleague == self.colleague_b:
self.colleague_a.receive(message)
# 具体同事类
class ConcreteColleagueA(Colleague):
def __init__(self, mediator):
self.mediator = mediator
def set_mediator(self, mediator):
self.mediator = mediator
def send(self, message):
self.mediator.send(message, self)
def receive(self, message):
print("同事A收到消息:", message)
class ConcreteColleagueB(Colleague):
def __init__(self, mediator):
self.mediator = mediator
def set_mediator(self, mediator):
self.mediator = mediator
def send(self, message):
self.mediator.send(message, self)
def receive(self, message):
print("同事B收到消息:", message)
# 客户端代码
if __name__ == "__main__":
mediator = ConcreteMediator()
colleague_a = ConcreteColleagueA(mediator)
colleague_b = ConcreteColleagueB(mediator)
mediator.set_colleague_a(colleague_a)
mediator.set_colleague_b(colleague_b)
colleague_a.send("Hello, colleague B!")
colleague_b.send("Hi, colleague A!")
(2) 中介者模式的应用场景
中介者模式适用于以下场景:
- 一组对象之间存在复杂的交互关系,导致对象之间的耦合度较高。
- 要求对象之间的交互逻辑可以灵活地改变,而不需要修改对象之间的引用关系。
(3) 中介者模式的优点
- 中介者模式将对象之间的交互逻辑封装到中介者对象中,从而使得对象之间的耦合度降低到最低。
- 中介者模式使得对象之间的交互逻辑可以灵活地改变,而不需要修改对象之间的引用关系。
- 中介者模式遵循开闭原则,新的同事类可以很容易地添加到系统中,而不会影响到原有的代码。
(4) 中介者模式的缺点
- 中介者模式中,中介者对象通常需要知道所有的同事类,可能会导致中介者对象的职责过重。
3.解释器模式
它定义了一种语言的文法,并解析相应的语句。解释器模式通过定义语言的文法,将文法中的每个规则映射到一个类,然后通过递归的方式解析语句。
(1) 解释器模式的结构
解释器模式的核心是解释器类,它封装了解释语句的逻辑。解释器类通常包含一个或多个解释方法,用于解释语句的不同部分。
以下是解释器模式的基本结构:
# 抽象表达式类
class AbstractExpression:
def interpret(self, context):
pass
# 终结符表达式类
class TerminalExpression(AbstractExpression):
def interpret(self, context):
# 解释终结符表达式的逻辑
pass
# 非终结符表达式类
class NonterminalExpression(AbstractExpression):
def __init__(self):
self.expressions = []
def add_expression(self, expression):
self.expressions.append(expression)
def interpret(self, context):
# 解释非终结符表达式的逻辑
for expression in self.expressions:
expression.interpret(context)
# 上下文类
class Context:
def __init__(self):
self.input = None
self.output = None
# 客户端代码
if __name__ == "__main__":
context = Context()
# 构建语法树
expression1 = TerminalExpression()
expression2 = NonterminalExpression()
expression3 = TerminalExpression()
expression2.add_expression(expression1)
expression2.add_expression(expression3)
# 解释语句
expression2.interpret(context)
(2) 解释器模式的应用场景
解释器模式适用于以下场景:
- 一种语言的文法比较简单,且文法的规则可以通过类来表达。
- 需要解析和执行一种特定的语言。
(3) 解释器模式的优点
- 解释器模式将解释语句的逻辑封装到解释器类中,使得解释语句的逻辑可以灵活地改变。
- 解释器模式遵循开闭原则,新的解释器类可以很容易地添加到系统中,而不会影响到原有的代码。
(4) 解释器模式的缺点
- 解释器模式中,解释器类通常需要知道所有的语法规则,可能会导致解释器类的职责过重。