目录

  1. 原型模式简介
  2. 原型模式的结构
  3. 原型模式的优缺点
  4. 原型模式的实现
    • 4.1 浅拷贝 vs 深拷贝
    • 4.2 Python 原型模式示例
  5. 原型模式的应用场景
  6. 出站链接
  7. 站内链接
  8. 参考资料

1. 原型模式简介

原型模式（Prototype Pattern） 是一种创建型设计模式，用于通过克隆已有对象来创建新对象，而不是直接实例化新的对象。

为什么使用原型模式？

  • 提升性能：避免重复创建对象，提高对象创建的效率。
  • 减少耦合：客户端代码无需依赖具体的构造方法。
  • 支持动态对象结构：在运行时可以修改对象，并创建相同配置的新对象。

典型应用

  • 游戏角色复制（复制已有角色并调整装备）
  • 文档模板（克隆已有文档并修改内容）
  • 网络请求（克隆请求对象并修改参数）

2. 原型模式的结构

原型模式主要包含以下两个核心角色：

角色作用
Prototype（原型接口）定义 clone() 方法，允许克隆自身
ConcretePrototype（具体原型）实现 clone() 方法，执行复制操作

UML 类图

┌────────────────────┐
│   Prototype       │  (原型接口)
│ + clone()         │
└────────▲─────────┘
         │
┌────────────────────┐
│ ConcretePrototype  │  (具体原型)
│ + clone()          │
└────────────────────┘

3. 原型模式的优缺点

✅ 优点

  1. 提高对象创建效率，避免重复构造相似对象。
  2. 降低耦合，无需依赖类的构造方法。
  3. 可以在运行时动态调整对象，然后克隆多个相同结构的对象。

❌ 缺点

  1. 深拷贝较复杂，涉及嵌套对象时，可能需要递归克隆。
  2. 不适合过于简单的对象，普通构造方法更直观。

4. 原型模式的实现

4.1 浅拷贝 vs 深拷贝

在 Python 中，复制对象时有 两种方式：

  • 浅拷贝（shallow copy）：
    • 复制对象的 基本数据类型（如 int、str）。
    • 共享 引用类型对象（如 list、dict）。
  • 深拷贝（deep copy）：
    • 递归复制所有对象，包括嵌套对象，保证独立副本。
import copy

original_list = [[1, 2, 3], 4, 5]

# 浅拷贝
shallow_copy = copy.copy(original_list)
shallow_copy[0].append(6)  # 修改原列表的嵌套列表

# 深拷贝
deep_copy = copy.deepcopy(original_list)
deep_copy[0].append(7)  # 仅修改深拷贝的列表

print(original_list)  # [[1, 2, 3, 6], 4, 5]
print(shallow_copy)   # [[1, 2, 3, 6], 4, 5]
print(deep_copy)      # [[1, 2, 3, 6, 7], 4, 5]

4.2 Python 原型模式示例

场景：创建一个汽车对象，然后克隆它以创建不同颜色的汽车。

import copy

# 1. 原型接口
class Prototype:
    def clone(self):
        return copy.deepcopy(self)

# 2. 具体原型
class Car(Prototype):
    def __init__(self, model, color, features):
        self.model = model
        self.color = color
        self.features = features  # 复杂对象（字典）

    def __str__(self):
        return f"Car(Model: {self.model}, Color: {self.color}, Features: {self.features})"

# 3. 客户端代码
car1 = Car("Tesla Model S", "Red", {"Autopilot": True, "Sunroof": False})
car2 = car1.clone()  # 复制对象
car2.color = "Blue"  # 修改克隆对象的属性
car2.features["Sunroof"] = True  # 修改嵌套对象

print(car1)  # Car(Model: Tesla Model S, Color: Red, Features: {'Autopilot': True, 'Sunroof': False})
print(car2)  # Car(Model: Tesla Model S, Color: Blue, Features: {'Autopilot': True, 'Sunroof': True})

5. 原型模式的应用场景

适用于以下情况

  1. 需要创建多个相似对象
    • 例如：游戏角色、汽车模型、家具配置。
  2. 对象创建成本高
    • 例如：数据库连接、网络请求。
  3. 动态调整对象
    • 例如：前端 UI 组件、表单数据。

真实案例

  • 前端 UI 组件
    • React/Vue 组件克隆（<Button primary /> -> <Button secondary />）。
  • 游戏角色
    • 复制角色模板，并修改装备。
  • 数据库 ORM
    • 复制查询对象（Query.clone()）。
  • JavaScript JSON 数据 let obj1 = { name: "Alice", age: 25 }; let obj2 = JSON.parse(JSON.stringify(obj1)); // 深拷贝 obj2.age = 30; console.log(obj1, obj2);

6. 出站链接

7. 站内链接

8. 参考资料

  • Gamma, E., Design Patterns: Elements of Reusable Object-Oriented Software (1994).
  • Martin, R. C., Clean Code: A Handbook of Agile Software Craftsmanship (2009).

总结

  • 原型模式适用于需要克隆复杂对象的场景，避免重复创建。
  • 支持浅拷贝和深拷贝，深拷贝适用于嵌套对象。
  • 应用广泛，如游戏角色、前端 UI、数据库 ORM。

如果你有具体的应用场景，欢迎讨论！🚀