编辑“︁原型模式（Prototype Pattern）”︁

{{DISPLAYTITLE:原型模式（Prototype Pattern）}}

'''原型模式'''是一种创建型设计模式，它通过复制现有对象（原型）来创建新对象，而不是通过类实例化。这种方式避免了重复初始化对象的开销，尤其适用于创建成本较高的对象或需要动态配置的场景。

== 核心概念 ==
原型模式的核心是**原型接口**（通常为<code>Cloneable</code>），它声明了一个克隆方法（如<code>clone()</code>）。具体原型类实现此接口，并定义如何复制自身的逻辑。

=== 模式结构 ===
<mermaid>
classDiagram
    class Prototype {
        <<interface>>
        +clone(): Prototype
    }
    class ConcretePrototype {
        -field: Any
        +clone(): Prototype
    }
    Prototype <|-- ConcretePrototype
</mermaid>

* '''Prototype'''：声明克隆方法的接口或抽象类。
* '''ConcretePrototype'''：实现克隆方法的具体类。

== 代码示例 ==
以下是一个Java实现的简单示例：

<syntaxhighlight lang="java">
// 1. 声明原型接口
interface Prototype extends Cloneable {
    Prototype clone() throws CloneNotSupportedException;
}

// 2. 实现具体原型类
class ConcretePrototype implements Prototype {
    private String field;

    public ConcretePrototype(String field) {
        this.field = field;
    }

    @Override
    public Prototype clone() throws CloneNotSupportedException {
        return (ConcretePrototype) super.clone(); // 浅拷贝
    }

    public String getField() {
        return field;
    }
}

// 3. 客户端使用
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        ConcretePrototype original = new ConcretePrototype("初始值");
        ConcretePrototype copy = (ConcretePrototype) original.clone();

        System.out.println("Original field: " + original.getField());
        System.out.println("Copied field: " + copy.getField());
    }
}
</syntaxhighlight>

'''输出结果：'''
<pre>
Original field: 初始值
Copied field: 初始值
</pre>

=== 关键点说明 ===
* 通过<code>clone()</code>方法复制对象时，默认是'''浅拷贝'''（仅复制基本类型和引用地址）。
* 如需'''深拷贝'''（递归复制引用对象），需重写<code>clone()</code>方法手动实现。

== 实际应用场景 ==
=== 场景1：游戏中的敌人生成 ===
在游戏中，同类型敌人（如小兵）可能有相同的初始属性但不同位置。使用原型模式可快速复制基础模板：
<syntaxhighlight lang="java">
class Enemy implements Cloneable {
    private String type;
    private int health;

    public Enemy(String type, int health) {
        this.type = type;
        this.health = health;
    }

    @Override
    public Enemy clone() {
        return new Enemy(this.type, this.health); // 深拷贝
    }
}

// 使用时：
Enemy skeletonTemplate = new Enemy("骷髅", 50);
Enemy skeleton1 = skeletonTemplate.clone();
</syntaxhighlight>

=== 场景2：配置对象复用 ===
当系统需要多个配置相似的对象时（如数据库连接参数），可通过原型避免重复初始化：
<syntaxhighlight lang="python">
import copy

class DBConnection:
    def __init__(self, host, user, password):
        self.host = host
        self.user = user
        self.password = password

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

# 基础配置模板
base_config = DBConnection("localhost", "admin", "123456")
dev_config = base_config.clone()
dev_config.host = "dev-db.example.com"
</syntaxhighlight>

== 深拷贝 vs 浅拷贝 ==
<mermaid>
flowchart LR
    A[原型对象] -->|浅拷贝| B[新对象]
    A --> C[引用对象]
    B --> C
    D[原型对象] -->|深拷贝| E[新对象]
    D --> F[引用对象]
    E --> G[新引用对象副本]
</mermaid>

* '''浅拷贝'''问题示例：
<syntaxhighlight lang="java">
class ShallowCopyExample implements Cloneable {
    List<String> items = new ArrayList<>();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 默认浅拷贝
    }
}
</syntaxhighlight>
修改拷贝对象的<code>items</code>会影响原对象！

== 数学建模 ==
原型模式可形式化为：
<math>
\text{clone}(p) = 
\begin{cases} 
p & \text{浅拷贝} \\
\text{deepCopy}(p) & \text{深拷贝}
\end{cases}
</math>
其中<math>\text{deepCopy}</math>需递归处理所有引用字段。

== 优缺点 ==
{| class="wikitable"
|+ 原型模式分析
! 优点 !! 缺点
|-
| 避免重复初始化开销 || 深拷贝实现复杂
|-
| 动态添加或删除产品 || 需小心循环引用
|-
| 隐藏创建细节 || 可能违反"里氏替换原则"
|}

== 与其他模式的关系 ==
* 与'''工厂方法模式'''：都用于创建对象，但原型模式通过复制，工厂方法通过子类化。
* 与'''单例模式'''：注意原型模式可能破坏单例的唯一性。

{{设计模式导航}}

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:设计模式]]