Java设计模式：提升代码质量与可维护性的利器_java 能显著提升代码实力的设计模式-CSDN博客

在Java开发中，设计模式是解决常见问题的经典解决方案。它们不仅帮助我们编写出更高效、更可维护的代码，还能提升团队协作的效率。本文将简要介绍Java开发中常用的几种设计模式，帮助开发者更好地理解和应用这些模式。java设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式，每一类都包含多种经典的设计模式。以下是对这些设计模式的分类和介绍。

一、创建型模式（Creational Patterns）

创建型模式关注对象的创建机制，帮助系统独立于对象的创建、组合和表示。

1. 单例模式（Singleton Pattern）

1.1 概述

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于需要严格控制资源访问的场景，如数据库连接、日志记录器等。

1.2 实现方式

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

# 使用示例
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # 输出: True

1.3 应用场景

数据库连接池
配置管理器
日志记录器

2. 工厂模式（Factory Pattern）

2.1 概述

工厂模式定义一个创建对象的接口，让子类决定实例化哪个类。这种模式将对象的创建过程封装起来，使得代码更加灵活和可维护。

2.2 实现方式

class Product:
    def use(self):
        pass

class ConcreteProductA(Product):
    def use(self):
        return "Using Product A"

class ConcreteProductB(Product):
    def use(self):
        return "Using Product B"

class Factory:
    def create_product(self, product_type):
        if product_type == "A":
            return ConcreteProductA()
        elif product_type == "B":
            return ConcreteProductB()
        else:
            raise ValueError("Unknown product type")

# 使用示例
factory = Factory()
product = factory.create_product("A")
print(product.use())  # 输出: Using Product A

2.3 应用场景

动态创建对象
解耦对象的创建和使用
支持多种产品类型

3. 抽象工厂模式（Abstract Factory Pattern）

3.1 概述

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。这种模式适用于需要创建多个产品族的场景。

3.2 实现方式

class AbstractFactory:
    def create_product_a(self):
        pass

    def create_product_b(self):
        pass

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA1()

    def create_product_b(self):
        return ConcreteProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA2()

    def create_product_b(self):
        return ConcreteProductB2()

# 使用示例
factory = ConcreteFactory1()
product_a = factory.create_product_a()
product_b = factory.create_product_b()
print(product_a.use(), product_b.use())

3.3 应用场景

跨平台UI组件库
数据库访问层
游戏中的角色和装备系统

4. 建造者模式（Builder Pattern）

4.1 概述

建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。这种模式适用于需要分步骤构建复杂对象的场景。

4.2 实现方式

class Product:
    def __init__(self):
        self.parts = []

    def add(self, part):
        self.parts.append(part)

    def list_parts(self):
        return f"Product parts: {', '.join(self.parts)}"

class Builder:
    def build_part_a(self):
        pass

    def build_part_b(self):
        pass

    def get_result(self):
        pass

class ConcreteBuilder(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("PartA1")

    def build_part_b(self):
        self.product.add("PartB1")

    def get_result(self):
        return self.product

class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct(self):
        self.builder.build_part_a()
        self.builder.build_part_b()

# 使用示例
builder = ConcreteBuilder()
director = Director(builder)
director.construct()
product = builder.get_result()
print(product.list_parts())  # 输出: Product parts: PartA1

5. 原型模式（Prototype Pattern）

5.1 概述

原型模式通过复制现有对象来创建新对象，而不是通过实例化类。这种模式适用于创建成本较高的对象，或者需要动态配置对象的场景。

5.2 实现方式

import copy

class Prototype:
    def clone(self):
        return copy.deepcopy(self)

class ConcretePrototype(Prototype):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"Prototype with value: {self.value}"

# 使用示例
prototype = ConcretePrototype(10)
clone = prototype.clone()
print(clone)  # 输出: Prototype with value: 10

5.3 应用场景

对象创建成本高（如数据库连接、网络请求）
动态配置对象
需要快速创建大量相似对象

6. 创建型模式的对比与选择

模式名称	核心思想	适用场景
单例模式	确保一个类只有一个实例，并提供全局访问点	需要严格控制资源访问的场景（如数据库连接、日志记录器）
工厂模式	定义一个创建对象的接口，让子类决定实例化哪个类	动态创建对象，解耦对象的创建和使用
抽象工厂模式	提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类	需要创建多个产品族的场景（如跨平台UI组件库、数据库访问层）
建造者模式	将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示	需要分步骤构建复杂对象的场景（如文档生成器、游戏角色创建）
原型模式	通过复制现有对象来创建新对象，而不是通过实例化类	对象创建成本高或需要快速创建大量相似对象的场景

创建型设计模式为对象的创建提供了灵活且可维护的解决方案。通过合理选择和应用这些模式，开发者可以有效地解耦对象的创建过程，提高代码的可扩展性和可维护性。以下是每种模式的核心价值：

单例模式：确保全局唯一实例，避免资源浪费。
工厂模式：将对象的创建过程封装，支持动态扩展。
抽象工厂模式：管理多个产品族，确保一致性。
建造者模式：分步骤构建复杂对象，支持多种表示。
原型模式：通过复制快速创建对象，降低创建成本。

在实际开发中，应根据具体需求选择合适的创建型模式，以构建高效、灵活且易于维护的软件系统。

二、结构型模式（Structural Patterns）

结构型设计模式（Structural Patterns）关注类和对象的组合，以形成更大的结构。这些模式帮助开发者设计出灵活、可扩展且易于维护的系统。本文将深入探讨七种主要的结构型模式：适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式，并通过实际案例展示它们的应用场景和优势。

1. 适配器模式（Adapter Pattern）

1.1 概述

适配器模式将一个类的接口转换成客户端期望的另一个接口，使得原本不兼容的类可以一起工作。这种模式常用于集成第三方库或遗留代码。

1.2 实现方式

class Target:
    def request(self):
        return "Target: The default target's behavior."

class Adaptee:
    def specific_request(self):
        return ".eetpadA eht fo roivaheb laicepS"

class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        return f"Adapter: (TRANSLATED) {self.adaptee.specific_request()[::-1]}"

# 使用示例
adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())  # 输出: Adapter: (TRANSLATED) Special behavior of the Adaptee.

1.3 应用场景

集成第三方库或API
适配遗留代码
统一接口调用

2. 桥接模式（Bridge Pattern）

2.1 概述

桥接模式将抽象部分与实现部分分离，使它们可以独立变化。这种模式适用于需要在多个维度上扩展功能的场景。

2.2 实现方式

class Implementation:
    def operation_implementation(self):
        pass

class ConcreteImplementationA(Implementation):
    def operation_implementation(self):
        return "ConcreteImplementationA: Here's the result on the platform A."

class ConcreteImplementationB(Implementation):
    def operation_implementation(self):
        return "ConcreteImplementationB: Here's the result on the platform B."

class Abstraction:
    def __init__(self, implementation):
        self.implementation = implementation

    def operation(self):
        return f"Abstraction: Base operation with:\n{self.implementation.operation_implementation()}"

# 使用示例
implementation = ConcreteImplementationA()
abstraction = Abstraction(implementation)
print(abstraction.operation())

2.3 应用场景

跨平台应用开发
多维度功能扩展
解耦抽象与实现

3. 组合模式（Composite Pattern）

3.1 概述

组合模式将对象组合成树形结构以表示“部分-整体”的层次结构，使得客户端可以统一处理单个对象和组合对象。

3.2 实现方式

class Component:
    def operation(self):
        pass

class Leaf(Component):
    def operation(self):
        return "Leaf"

class Composite(Component):
    def __init__(self):
        self.children = []

    def add(self, component):
        self.children.append(component)

    def operation(self):
        results = []
        for child in self.children:
            results.append(child.operation())
        return f"Branch({'+'.join(results)})"

# 使用示例
leaf1 = Leaf()
leaf2 = Leaf()
composite = Composite()
composite.add(leaf1)
composite.add(leaf2)
print(composite.operation())  # 输出: Branch(Leaf+Leaf)

3.3 应用场景

文件系统管理
UI组件树
组织结构管理

4. 装饰器模式（Decorator Pattern）

4.1 概述

装饰器模式动态地给对象添加功能，而不改变其结构。这种模式适用于需要灵活扩展对象功能的场景。

4.2 实现方式

class Component:
    def operation(self):
        return "Component"

class Decorator(Component):
    def __init__(self, component):
        self.component = component

    def operation(self):
        return self.component.operation()

class ConcreteDecoratorA(Decorator):
    def operation(self):
        return f"ConcreteDecoratorA({self.component.operation()})"

class ConcreteDecoratorB(Decorator):
    def operation(self):
        return f"ConcreteDecoratorB({self.component.operation()})"

# 使用示例
component = Component()
decoratorA = ConcreteDecoratorA(component)
decoratorB = ConcreteDecoratorB(decoratorA)
print(decoratorB.operation())  # 输出: ConcreteDecoratorB(ConcreteDecoratorA(Component))

4.3 应用场景

动态扩展对象功能
日志记录、权限校验等横切关注点
避免使用子类扩展功能

5. 外观模式（Facade Pattern）

5.1 概述

外观模式为子系统中的一组接口提供一个统一的接口，简化客户端的使用。这种模式常用于隐藏系统的复杂性。

5.2 实现方式

class SubsystemA:
    def operation_a(self):
        return "SubsystemA: Ready!"

class SubsystemB:
    def operation_b(self):
        return "SubsystemB: Go!"

class Facade:
    def __init__(self):
        self.subsystem_a = SubsystemA()
        self.subsystem_b = SubsystemB()

    def operation(self):
        result = []
        result.append(self.subsystem_a.operation_a())
        result.append(self.subsystem_b.operation_b())
        return "\n".join(result)

# 使用示例
facade = Facade()
print(facade.operation())
# 输出:
# SubsystemA: Ready!
# SubsystemB: Go!

5.3 应用场景

简化复杂系统的调用
提供统一的API接口
降低客户端与子系统的耦合度

6. 享元模式（Flyweight Pattern）

6.1 概述

享元模式通过共享技术有效地支持大量细粒度的对象。这种模式适用于需要优化内存使用或性能的场景。

6.2 实现方式

class Flyweight:
    def __init__(self, shared_state):
        self.shared_state = shared_state

    def operation(self, unique_state):
        return f"Flyweight: Shared({self.shared_state}) and Unique({unique_state})."

class FlyweightFactory:
    _flyweights = {}

    def get_flyweight(self, shared_state):
        if shared_state not in self._flyweights:
            self._flyweights[shared_state] = Flyweight(shared_state)
        return self._flyweights[shared_state]

# 使用示例
factory = FlyweightFactory()
flyweight1 = factory.get_flyweight("state1")
flyweight2 = factory.get_flyweight("state1")
print(flyweight1.operation("unique1"))  # 输出: Flyweight: Shared(state1) and Unique(unique1).
print(flyweight2.operation("unique2"))  # 输出: Flyweight: Shared(state1) and Unique(unique2).

6.3 应用场景

文本编辑器中的字符对象
游戏中的粒子系统
数据库连接池

7. 代理模式（Proxy Pattern）

7.1 概述

代理模式为其他对象提供一个代理，以控制对这个对象的访问。这种模式适用于需要延迟加载、访问控制或日志记录的场景。

7.2 实现方式

class Subject:
    def request(self):
        pass

class RealSubject(Subject):
    def request(self):
        return "RealSubject: Handling request."

class Proxy(Subject):
    def __init__(self, real_subject):
        self.real_subject = real_subject

    def request(self):
        if self.check_access():
            return self.real_subject.request()
        else:
            return "Proxy: Access denied."

    def check_access(self):
        return True

# 使用示例
real_subject = RealSubject()
proxy = Proxy(real_subject)
print(proxy.request())  # 输出: RealSubject: Handling request.

7.3 应用场景

延迟加载（如大文件或数据库查询）
访问控制（如权限校验）
日志记录或监控

8. 结构型模式的对比与选择

模式名称	核心思想	适用场景
适配器模式	将一个类的接口转换成客户端期望的另一个接口	集成第三方库或遗留代码
桥接模式	将抽象部分与实现部分分离，使它们可以独立变化	跨平台应用开发、多维度功能扩展
组合模式	将对象组合成树形结构以表示“部分-整体”的层次结构	文件系统管理、UI组件树、组织结构管理

装饰器模式	动态地给对象添加功能，而不改变其结构	动态扩展对象功能、日志记录、权限校验
外观模式	为子系统中的一组接口提供一个统一的接口，简化客户端的使用	简化复杂系统的调用、提供统一的API接口
享元模式	通过共享技术有效地支持大量细粒度的对象	文本编辑器中的字符对象、游戏中的粒子系统、数据库连接池
代理模式	为其他对象提供一个代理，以控制对这个对象的访问	延迟加载、访问控制、日志记录或监控

结构型设计模式通过类和对象的组合，帮助开发者构建灵活、可扩展且易于维护的系统。以下是每种模式的核心价值：

适配器模式：解决接口不兼容问题，实现无缝集成。
桥接模式：分离抽象与实现，支持多维度扩展。
组合模式：统一处理部分-整体关系，简化复杂结构。
装饰器模式：动态扩展功能，避免子类膨胀。
外观模式：简化复杂系统的调用，提供统一接口。
享元模式：优化内存使用，支持大量细粒度对象。
代理模式：控制对象访问，支持延迟加载和权限校验。

在实际开发中，应根据具体需求选择合适的结构型模式，以构建高效、灵活且易于维护的软件系统。通过合理应用这些模式，开发者可以更好地管理系统的复杂性，提高代码的可复用性和可扩展性。

三、行为型模式（Behavioral Patterns）

行为型设计模式（Behavioral Patterns）关注对象之间的职责分配和通信，帮助开发者设计出灵活、可扩展且易于维护的系统。本文将深入探讨十一种主要的行为型模式：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式，并通过实际案例展示它们的应用场景和优势。

1. 责任链模式（Chain of Responsibility Pattern）

1.1 概述

责任链模式将请求的发送者和接收者解耦，使多个对象都有机会处理请求。这种模式常用于需要逐级处理请求的场景。

1.2 实现方式

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

    def handle(self, request):
        if self.successor:
            return self.successor.handle(request)
        return None

class ConcreteHandlerA(Handler):
    def handle(self, request):
        if request == "A":
            return f"ConcreteHandlerA handled {request}"
        return super().handle(request)

class ConcreteHandlerB(Handler):
    def handle(self, request):
        if request == "B":
            return f"ConcreteHandlerB handled {request}"
        return super().handle(request)

# 使用示例
handler_chain = ConcreteHandlerA(ConcreteHandlerB())
print(handler_chain.handle("A"))  # 输出: ConcreteHandlerA handled A
print(handler_chain.handle("B"))  # 输出: ConcreteHandlerB handled B

1.3 应用场景

请求的逐级处理（如审批流程）
事件处理系统
异常处理机制

2. 命令模式（Command Pattern）

2.1 概述

命令模式将请求封装为对象，使得可以用不同的请求对客户进行参数化。这种模式适用于需要支持撤销操作或记录日志的场景。

2.2 实现方式

class Command:
    def execute(self):
        pass

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self.receiver = receiver

    def execute(self):
        return self.receiver.action()

class Receiver:
    def action(self):
        return "Receiver: Executing action."

class Invoker:
    def __init__(self):
        self.command = None

    def set_command(self, command):
        self.command = command

    def execute_command(self):
        return self.command.execute()

# 使用示例
receiver = Receiver()
command = ConcreteCommand(receiver)
invoker = Invoker()
invoker.set_command(command)
print(invoker.execute_command())  # 输出: Receiver: Executing action.

2.3 应用场景

支持撤销操作
记录日志或事务
任务队列管理

3. 解释器模式（Interpreter Pattern）

3.1 概述

解释器模式定义语言的文法，并用解释器来解释语言中的句子。这种模式适用于需要解析特定语法规则的场景。

3.2 实现方式

class Context:
    def __init__(self, input):
        self.input = input
        self.output = None

class AbstractExpression:
    def interpret(self, context):
        pass

class TerminalExpression(AbstractExpression):
    def interpret(self, context):
        context.output = f"Terminal: {context.input}"

class NonTerminalExpression(AbstractExpression):
    def interpret(self, context):
        context.output = f"NonTerminal: {context.input}"

# 使用示例
context = Context("input data")
expression = TerminalExpression()
expression.interpret(context)
print(context.output)  # 输出: Terminal: input data

3.3 应用场景

解析特定语法规则
编译器或解释器
规则引擎

4. 迭代器模式（Iterator Pattern）

4.1 概述

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示。这种模式适用于需要遍历复杂数据结构的场景。

4.2 实现方式

class Iterator:
    def __init__(self, collection):
        self.collection = collection
        self.index = 0

    def has_next(self):
        return self.index < len(self.collection)

    def next(self):
        item = self.collection[self.index]
        self.index += 1
        return item

class Iterator:
    def __init__(self, collection):
        self.collection = collection
        self.index = 0

    def has_next(self):
        return self.index < len(self.collection)

    def next(self):
        item = self.collection[self.index]
        self.index += 1
        return item

class Collection:
    def __init__(self):
        self.items = []

    def add_item(self, item):
        self.items.append(item)

    def get_iterator(self):
        return Iterator(self.items

4.3 应用场景

遍历复杂数据结构（如树、图）
隐藏集合的内部实现
支持多种遍历方式

5. 中介者模式（Mediator Pattern）

5.1 概述

中介者模式用一个中介对象来封装一系列对象之间的交互，使它们不需要显式地相互引用。这种模式适用于减少对象间直接耦合的场景。

5.2 实现方式

class Mediator:
    def notify(self, sender, event):
        pass

class ConcreteMediator(Mediator):
    def __init__(self, component1, component2):
        self.component1 = component1
        self.component2 = component2
        self.component1.mediator = self
        self.component2.mediator = self

    def notify(self, sender, event):
        if event == "A":
            print("Mediator reacts on A and triggers following operations:")
            self.component2.do_c()
        elif event == "D":
            print("Mediator reacts on D and triggers following operations:")
            self.component1.do_b()

class BaseComponent:
    def __init__(self, mediator=None):
        self.mediator = mediator

    def set_mediator(self, mediator):
        self.mediator = mediator

class Component1(BaseComponent):
    def do_a(self):
        print("Component 1 does A.")
        self.mediator.notify(self, "A")

    def do_b(self):
        print("Component 1 does B.")

class Component2(BaseComponent):
    def do_c(self):
        print("Component 2 does C.")

    def do_d(self):
        print("Component 2 does D.")
        self.mediator.notify(self, "D")

# 使用示例
c1 = Component1()
c2 = Component2()
mediator = ConcreteMediator(c1, c2)

c1.do_a()  # 输出: Component 1 does A. \n Mediator reacts on A and triggers following operations: \n Component 2 does C.
c2.do_d()  # 输出: Component 2 does D. \n Mediator reacts on D and triggers following operations: \n Component 1 does B.

5.3 应用场景

减少对象间直接耦合
复杂交互逻辑的集中管理
聊天系统或事件驱动系统

6. 备忘录模式（Memento Pattern）

6.1 概述

备忘录模式在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这种模式适用于需要支持撤销操作的场景。

6.2 实现方式

class Memento:
    def __init__(self, state):
        self.state = state

    def get_state(self):
        return self.state

class Originator:
    def __init__(self):
        self.state = None

    def set_state(self, state):
        self.state = state

    def save_to_memento(self):
        return Memento(self.state)

    def restore_from_memento(self, memento):
        self.state = memento.get_state()

class Caretaker:
    def __init__(self):
        self.mementos = []

    def add_memento(self, memento):
        self.mementos.append(memento)

    def get_memento(self, index):
        return self.mementos[index]

# 使用示例
originator = Originator()
caretaker = Caretaker()

originator.set_state("State 1")
caretaker.add_memento(originator.save_to_memento())

originator.set_state("State 2")
caretaker.add_memento(originator.save_to_memento())

originator.restore_from_memento(caretaker.get_memento(0))
print(originator.state)  # 输出: State 1

6.3 应用场景

支持撤销操作
保存和恢复对象状态
游戏存档功能

7. 观察者模式（Observer Pattern）

7.1 概述

观察者模式定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会收到通知。这种模式适用于需要实现事件驱动系统的场景。

7.2 实现方式

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

class Observer:
    def update(self, subject):
        pass

class ConcreteObserverA(Observer):
    def update(self, subject):
        print("ConcreteObserverA: Reacted to the event.")

class ConcreteObserverB(Observer):
    def update(self, subject):
        print("ConcreteObserverB: Reacted to the event.")

# 使用示例
subject = Subject()
observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()

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

subject.notify()
# 输出:
# ConcreteObserverA: Reacted to the event.
# ConcreteObserverB: Reacted to the event.

7.3 应用场景

事件驱动系统
发布-订阅模式
GUI 事件处理

8. 状态模式（State Pattern）

8.1 概述

状态模式允许对象在其内部状态改变时改变它的行为。这种模式适用于需要根据状态改变行为的场景。

8.2 实现方式

class State:
    def handle(self, context):
        pass

class ConcreteStateA(State):
    def handle(self, context):
        print("State A handling request.")
        context.state = ConcreteStateB()

class ConcreteStateB(State):
    def handle(self, context):
        print("State B handling request.")
        context.state = ConcreteStateA()

class Context:
    def __init__(self):
        self.state = ConcreteStateA()

    def request(self):
        self.state.handle(self)

# 使用示例
context = Context()
context.request()  # 输出: State A handling request.
context.request()  # 输出: State B handling request.

8.3 应用场景

状态机实现
根据状态改变行为
游戏角色状态管理

9. 策略模式（Strategy Pattern）

9.1 概述

策略模式定义一系列算法，并将它们封装起来，使它们可以互换。这种模式适用于需要在运行时选择算法的场景。

9.2 实现方式

class Strategy:
    def execute(self, data):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self, data):
        return f"Strategy A: {data}"

class ConcreteStrategyB(Strategy):
    def execute(self, data):
        return f"Strategy B: {data}"

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_strategy(self, data):
        return self.strategy.execute(data)

# 使用示例
context = Context(ConcreteStrategyA())
print(context.execute_strategy("Data"))  # 输出: Strategy A: Data

context.strategy = ConcreteStrategyB()
print(context.execute_strategy("Data"))  # 输出: Strategy B: Data

9.3 应用场景

运行时选择算法
多种排序或搜索策略
支付方式选择

10. 模板方法模式（Template Method Pattern）

10.1 概述

模板方法模式定义一个算法的骨架，而将一些步骤延迟到子类中。这种模式适用于需要固定算法流程但允许部分步骤自定义的场景。

10.2 实现方式

class AbstractClass:
    def template_method(self):
        self.base_operation1()
        self.required_operation1()
        self.base_operation2()
        self.hook()

    def base_operation1(self):
        print("AbstractClass: Base Operation 1")

    def base_operation2(self):
        print("AbstractClass: Base Operation 2")

    def required_operation1(self):
        pass

    def hook(self):
        pass

class ConcreteClass(AbstractClass):
    def required_operation1(self):
        print("ConcreteClass: Required Operation 1")

    def hook(self):
        print("ConcreteClass: Hook")

# 使用示例
concrete_class = ConcreteClass()
concrete_class.template_method()
# 输出:
# AbstractClass: Base Operation 1
# ConcreteClass: Required Operation 1
# AbstractClass: Base Operation 2
# ConcreteClass: Hook

10.3 应用场景

固定算法流程但允许部分步骤自定义
框架设计
代码复用

11. 访问者模式（Visitor Pattern）

11.1 概述

访问者模式表示一个作用于某对象结构中的各元素的操作，使得可以在不改变各元素类的前提下定义作用于这些元素的新操作。这种模式适用于需要对复杂对象结构进行多种操作的场景。

11.2 实现方式

class Element:
    def accept(self, visitor):
        pass

class ConcreteElementA(Element):
    def accept(self, visitor):
        visitor.visit_concrete_element_a(self)

    def operation_a(self):
        return "ConcreteElementA: Operation A"

class ConcreteElementB(Element):
    def accept(self, visitor):
        visitor.visit_concrete_element_b(self)

    def operation_b(self):
        return "ConcreteElementB: Operation B"

class Visitor:
    def visit_concrete_element_a(self, element):
        pass

    def visit_concrete_element_b(self, element):
        pass

class ConcreteVisitor1(Visitor):
    def visit_concrete_element_a(self, element):
        print(f"ConcreteVisitor1: {element.operation_a()}")

    def visit_concrete_element_b(self, element):
        print(f"ConcreteVisitor1: {element.operation_b()}")

class ConcreteVisitor2(Visitor):
    def visit_concrete_element_a(self, element):
        print(f"ConcreteVisitor2: {element.operation_a()}")

    def visit_concrete_element_b(self, element):
        print(f"ConcreteVisitor2: {element.operation_b()}")

# 使用示例
elements = [ConcreteElementA(), ConcreteElementB()]
visitor1 = ConcreteVisitor1()
visitor2 = ConcreteVisitor2()

for element in elements:
    element.accept(visitor1)
    element.accept(visitor2)
# 输出:
# ConcreteVisitor1: ConcreteElementA: Operation A
# ConcreteVisitor2: ConcreteElementA: Operation A
# ConcreteVisitor1: ConcreteElementB: Operation B
# ConcreteVisitor2: ConcreteElementB: Operation B

11.3 应用场景

对复杂对象结构进行多种操作
分离数据结构与操作
扩展功能而不修改类

行为型模式的对比与选择

模式名称	核心思想	适用场景
责任链模式	将请求的发送者和接收者解耦，使多个对象都有机会处理请求	请求的逐级处理（如审批流程）
命令模式	将请求封装为对象，使得可以用不同的请求对客户进行参数化	支持撤销操作、记录日志或事务
解释器模式	定义语言的文法，并用解释器来解释语言中的句子	解析特定语法规则、编译器或解释器
迭代器模式	提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示	遍历复杂数据结构、隐藏集合的内部实现
中介者模式	用一个中介对象来封装一系列对象之间的交互，使它们不需要显式地相互引用	减少对象间直接耦合、复杂交互逻辑的集中管理
备忘录模式	在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态	支持撤销操作、保存和恢复对象状态
观察者模式	定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会收到通知	事件驱动系统、发布-订阅模式
状态模式	允许对象在其内部状态改变时改变它的行为	状态机实现、根据状态改变行为
策略模式	定义一系列算法，并将它们封装起来，使它们可以互换	运行时选择算法、多种排序或搜索策略
模板方法模式	定义一个算法的骨架，而将一些步骤延迟到子类中	固定算法流程但允许部分步骤自定义、框架设计
访问者模式	表示一个作用于某对象结构中的各元素的操作，使得可以在不改变各元素类的前提下定义作用于这些元素的新操作对复杂对象结构进行多种操作、分离数据结构与操作、扩展功能而不修改类