1 意图

原型模式让你能够复制已有对象，又无需使代码依赖对象所属的类。

2 问题

如果有一个对象，希望生成与其完全相同的一个复制品，该如何实现？首先，必须新建一个属于相同类的对象；然后，必须遍历原始对象的所有成员变量，将成员变量值复制到新对象中。
然而，不是所有对象都能通过这种方式进行复制：有些对象可能有私有成员变量，在对象外部是不可见的。

此外，必须知道对象所属的类才能创建复制品（需要构造函数），代码必须依赖该类。即使这是可以接受的，还可能有问题：有时候得到的是接口，不知道具体类。比如说，可以向方法的参数传入实现了某个接口的任何对象。

3 解决方案

原型模式为所有支持克隆的对象声明一个通用接口，通过该接口可以克隆对象，又无需将代码与具体的对象类耦合。这个通用接口通常仅仅只有一个克隆方法：克隆过程被委派给支持克隆的具体类。
所有类的克隆方法的实现都是非常相似的。支持克隆的对象就是原型。当对象有几十个成员变量、几百种类型时，对其进行克隆甚至可以代替子类的构造。运作方式如下：创建一系列不同类型的对象，用不同的方式进行配置。如果需要的对象与预先配置的对象相同，则只需要克隆原型，无需新建一个对象。

4 结构

4.1 基本实现

• 原型(Prototype) 接口声明克隆方法。绝大多数情况下，接口只有一个名为clone的方法。
• 具体原型(concrete prototype) 将实现克隆方法。除了将原始对象的数据复制到克隆体中之外，有时候还需要处理极端情况，如克隆关联对象、梳理递归依赖等。
• 客户端(client) 可以复制实现了原型接口的任何对象。

4.2 原型注册表

原型注册表(prototype registry) 存储了一系列可供随时复制的预生成对象，提供了访问常用原型的简单方法。最简单的注册表原型是一个名称 --> 原型的哈希表。但如果要使用名称之外的条件进行搜索，可以创建更加完善的注册表。

5 伪代码

// 基础原型。
abstract class Shape is
    field X: int
    field Y: int
    field color: string
    // 常规构造函数。
    constructor Shape() is
        // ...
    // 原型构造函数。使用已有对象的数值来初始化一个新对象。
    constructor Shape(source: Shape) is
        this()
        this.X = source.X
        this.Y = source.Y
        this.color = source.color
    // clone（克隆）操作会返回一个形状子类。
    abstract method clone():Shape
// 具体原型。克隆方法会创建一个新对象并将其传递给构造函数。直到构造函数运
// 行完成前，它都拥有指向新克隆对象的引用。因此，任何人都无法访问未完全生
// 成的克隆对象。这可以保持克隆结果的一致。
class Rectangle extends Shape is
    field width: int
    field height: int
    constructor Rectangle(source: Rectangle) is
        // 需要调用父构造函数来复制父类中定义的私有成员变量。
        super(source)
        this.width = source.width
        this.height = source.height
    method clone():Shape is
        return new Rectangle(this)
class Circle extends Shape is
    field radius: int
    constructor Circle(source: Circle) is
        super(source)
        this.radius = source.radius
    method clone():Shape is
        return new Circle(this)
// 客户端代码中的某个位置。
class Application is
    field shapes: array of Shape
    constructor Application() is
        Circle circle = new Circle()
        circle.X = 10
        circle.Y = 10
        circle.radius = 20
        shapes.add(circle)
        Circle anotherCircle = circle.clone()
        shapes.add(anotherCircle)
        // 变量 `anotherCircle（另一个圆）`与 `circle（圆）`对象的内
        // 容完全一样。
        Rectangle rectangle = new Rectangle()
        rectangle.width = 10
        rectangle.height = 20
        shapes.add(rectangle)
    method businessLogic() is
        // 原型是很强大的东西，因为它能在不知晓对象类型的情况下生成一个与
        // 其完全相同的复制品。
        Array shapesCopy = new Array of Shapes.
        // 例如，我们不知晓形状数组中元素的具体类型，只知道它们都是形状。
        // 但在多态机制的帮助下，当我们在某个形状上调用 `clone（克隆）`
        // 方法时，程序会检查其所属的类并调用其中所定义的克隆方法。这样，
        // 我们将获得一个正确的复制品，而不是一组简单的形状对象。
        foreach (s in shapes) do
            shapesCopy.add(s.clone())
        // `shapesCopy（形状副本）`数组中包含 `shape（形状）`数组所有
        // 子元素的复制品。

6 应用场景

• 需要复制一些对象，又希望代码独立于对象所属的具体类，可以使用原型模式。
  通常出现在代码需要处理第三方代码通过接口传递过来的对象时。即使不考虑代码耦合，也不能依赖对象所属的具体类，因为不知道具体类是什么。
  原型模式为客户端代码提供一个通用接口，客户端可以通过接口与对象进行交互，让客户端独立于具体类。
• 如果子类的区别仅在于对象的初始化方式，则可以使用原型模式来减少子类数量。创建子类的目的可能是为了创建特定类型的对象。
  原型模式中，可以使用一系列预生成的、各种类型的对象作为原型。
  客户端不必根据需求对子类进行实例化，只需要找到合适的原型，并对其进行克隆即可。

7 实现方式

1. 创建原型接口，在其中声明克隆方法。如果已有类层次结构，则需要在所有类中添加克隆方法。
2. 原型类必须另行定义一个以该类对象为参数的构造函数（拷贝构造函数）。这个构造函数必须复制对象的所有成员变量值到新建实体中。如果要修改子类，则必须调用父类构造函数，让父类复制其私有成员变量值。
   如果编程语言不支持方法重载，则需要定义一个特殊方法来复制对象数据。在构造函数中进行这种复制比较方便，因为调用new运算符可以马上得到结果对象。
3. 克隆方法通常只有一行代码：使用new运算符调用原型版本的构造函数（拷贝构造函数）。注意：每个类都必须显式重写克隆方法，使用自身类名调用new运算符。否则，克隆方法可能会生成父类对象。
4. 可以创建一个中心化的原型注册表，存储常用原型。
   可以新建一个工厂类来实现注册表，或者在原型基类中增加一个获取原型的静态方法。这个方法必须能够根据客户端代码设定的条件进行搜索。搜索条件可以是简单的字符串，或者是一组复杂的搜索参数。找到合适的原型后，注册表应对原型进行克隆，将复制生成的对象返回给客户端。
   最后需要将对子类构造函数的直接调用替换为对原型注册表工厂方法的调用。

8 优缺点

• 可以克隆对象，无需与具体类耦合。
• 可以克隆预先生成的原型，避免反复运行初始化代码。
• 可以更方便地生成复杂对象。
• 可以用继承之外的方式处理复杂对象的不同配置。
• 缺点：克隆包含循环引用的复杂对象可能会非常麻烦。

9 与其他模式的关系

• 许多设计工作初期使用工厂方法模式（简单，可以更方便地通过子类进行定制），随后演化成使用抽象工厂模式、原型模式、生成器模式（更灵活但是更复杂）。
• 抽象工厂模式通常基于一组工厂方法，但也可以使用原型模式来生成这些类的方法。
• 原型可以用于保存命令模式的历史记录。
• 大量使用组合模式和装饰模式的设计，通常可以从使用原型获益。可以通过该模式来复制复杂结构，而不是从零开始重新构造。
• 原型不基于继承，没有继承的缺点。另一方面，原型需要对被复制的对象进行复杂的初始化。工厂方法基于继承，但是不需要初始化步骤。
• 有时候原型可以作为备忘录模式的简化版本，条件是需要在历史记录中存储的对象的状态比较简单，不需要链接其他外部资源，或者可以方便地重建链接。
• 抽象工厂、生成器、原型都可以用单例模式来实现。

10 代码示例

10.1 原型接口

package main
type inode interface {
    print(string)
    clone() inode
}

10.2 具体原型: file

package main
import "fmt"
type file struct {
    name string
}
func (f *file) print(indentation string) {
    fmt.Println(indentation + f.name + "_clone")
}
func (f *file) clone() inode {
    return &file{name: f.name}
}

10.3 具体原型: folder

package main
import "fmt"
type folder struct {
    childrens []inode
    name      string
}
func (f *folder) print(indentation string) {
    fmt.Println(indentation + f.name)
    for _, i := range f.childrens {
        i.print(indentation + indentation)
    }
}
func (f *folder) clone() inode {
    cloneFolder := &folder{name: f.name + "_clone"}
    var tempChildrens []inode
    for _, i := range f.childrens {
        copy := i.clone()
        tempChildrens = append(tempChildrens, copy)
    }
    cloneFolder.childrens = tempChildrens
    return cloneFolder
}

10.4 客户端

package main
import "fmt"
func main() {
    file1 := &file{name: "File1"}
    file2 := &file{name: "File2"}
    file3 := &file{name: "File3"}
    folder1 := &folder{
        childrens: []inode{file1},
        name:      "Folder1",
    }
    folder2 := &folder{
        childrens: []inode{folder1, file2, file3},
        name:      "Folder2",
    }
    fmt.Println("\nPrinting hierarchy for Folder2")
    folder2.print("  ")
    cloneFolder := folder2.clone()
    fmt.Println("\nPrinting hierarchy for clone Folder")
    cloneFolder.print("  ")
}