本帖介绍 Prototype Pattern (原型模式)，并以一个「人事招聘程序」作为示例来说明。
--------------------------------------------------------
本帖的示例下载点：
http://files.cnblogs.com/WizardWu/090713.zip
第一个示例为 Console Mode (控制台应用程序) 项目，第二个示例为 ASP.NET 网站项目。
执行示例需要 Visual Studio 2008 或 IIS + .NET 3.0，不需要数据库。
--------------------------------------------------------
Prototype Pattern (原型模式)
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
－ Design Patterns: Elements of Reusable Object-Oriented Software
原型模式就是以一个既有的原型实例当作范本，利用复制的方式，动态获得这个原型实例的状态以及全部的字段和属性，以此创建一或多个相同的对象，而且不需要知道任何创建的细节。
Prototype 模式打个通俗的比方：假如您在图书馆看到几本自己喜欢的书籍，当看到某些知识点时，想在上面作相关记号，但由于其是图书馆的书，不能在上面乱涂乱画。此时您只好把相关的章节，用复印机把它复印出来，然后在自己复印的纸张上作记号。在 Prototype Pattern 里，Clone 方法就如同此种复印的动作，用户从一个既有的原型实例 (如同图书馆里的书)，复印后得到一或多个新的拷贝，不会破坏原本的原型，且用户不必知道原型的内容和格式。
Prototype 也具有一种「展示」的意味，就像是车展上的「原型」车款。当您对某个车款感兴趣时，您可购买相同的车款，而不是车展上展示的那辆车。
在软件设计方面，也常需要进行此种对象复制。例如我们要写一套室内设计软件，软件的操作界面上有一条 Toolbar，用户只要单击 Toolbar 上的 Button，或用鼠标拖曳到设计窗格中，就可创建一个桌子或椅子的副本，并可事后改变它的颜色或位置。当设计师改变设计图中的副本对象时，Toolbar 上的「原型」对象并不会跟着被改变。同样的观念，亦适用于工业设计 CAD 软件、图像处理软件，以及 Visual Studio 等各种软件的设计。
Prototype 模式的重点在于 Clone 方法，它负责复制 (克隆) 出一个新的对象并返回，而不是用 new 运算符和某个类的构造函数去创建实例。在此模式中，派生类如何覆写父类的 Clone 方法将是重点。而 clone 的方式，又可分为「浅拷贝 (shallow copy)」和「深拷贝 (deep copy)」，在介绍这个 Prototype 模式之前，先简单介绍一下这两种拷贝方式的差异 [1], [2], [3], [4] ：
- 浅拷贝; 浅表复制 (shallow copy)：对象拷贝时，如果字段是「值类型 (Value Type)」，则直接复制其值 (亦即复制整个字段)；若字段为「引用类型 (Reference Type)」，则只复制其「引用 (reference; pointer)」，但不复制引用的字段，亦即若更改了任一个副本对象的某一个「引用类型」字段，则原型正本对象、其他副本对象，也全部会一并更改 (如同本帖的第三个示例 02_Employee / 02_ShallowCopy_fail.aspx.cs)，也就是说正本和所有的副本，都指向了内存的同一个位置。
- 深拷贝; 深层复制 (deep copy)：不论对象的字段为「值类型」或「引用类型」，都会完整地复制，而且这些字段和属性都是完全独立的。在深拷贝中，所有的对象都是重复的。
另补充，.NET 的类型系统，分为「值类型」、「引用类型」两种，其对象在内存中的存储方式不同，如下：
- 值类型：只需要一段单独的内存，用于存储实际的数据在「栈 (Stack)」里，例如：int、byte、float、double、bool、struct、enum、char、...等类型。
- 引用类型：需要两段内存，第一段存储实际的数据，其总是位于「堆 (Heap)」中；第二段是一个存在「栈」里的引用 (reference; pointer)，其指向数据在「堆」中的实际存放位置，例如：object、string、class (包括自定义类)、interface、delegate、array (参考本帖的第三、第四个示例) 等类型。
但 string (字符串) 较特殊。string 虽然是「引用类型」，但却拥有「值类型」的特性。在 Prototype Pattern 及本帖的四个示例中，当透过 MemberwiseClone 方法做「浅拷贝」时，对象的 string 字段仍会被完整地复制，其结果就如同 int 等「值类型」的字段一样。
如下图 1 及下方示例 01_Shell，我们可透过自定义的 Prototype 抽象类，搭配 .NET 最顶层基类 System.Object 的 MemberwiseClone 方法，达成对象的「浅拷贝」，亦即复制某个对象其所有「字段 (field)」的值；但在 .NET 中，亦可舍弃此一自定义抽象类，让图 1 中的 ConcretePrototype1 类、ConcretePrototype2 类，改为实现 .NET 原生的 System.ICloneable 接口，透过实现此接口唯一的一个 Clone 方法，来达成对象的「浅拷贝」或「深拷贝」。
图 1 此图为 Prototype 模式的经典类图
01_Shell / Program.cs
using System;
namespace _01_Shell
{
//客户端程序
class Program
{
static void Main(string[] args)
{
ConcretePrototype1 p1 = new ConcretePrototype1("I"); //原型对象(来自外部的第一个实例)
ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone(); //浅拷贝(shallow copy)
Console.WriteLine("Cloned: {0}", c1.Id);
ConcretePrototype2 p2 = new ConcretePrototype2("II"); //原型对象(来自外部的第一个实例)
ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone(); //浅拷贝(shallow copy)
Console.WriteLine("Cloned: {0}", c2.Id);
Console.Read();
}
}
//每个具体的「原型」类，要实现的抽象类或接口。
//亦可舍弃此一自定义抽象类或接口，让 ConcretePrototype 类改为实现 .NET 原生的 System.ICloneable 接口
abstract class Prototype
{
private string id; //这个字段在派生类的 Clone 方法被调用时，会自动被拷贝
public Prototype(string id) //构造函数
{
this.id = id;
}
public string Id
{
get { return id; }
}
//返回 Prototype 类型。
public abstract Prototype Clone();
}
class ConcretePrototype1 : Prototype
{
public ConcretePrototype1(string id) //构造函数
: base(id)
{
}
//返回 Prototype 类型。在客户端程序中，依赖和获得的是 Prototype 抽象类，并以其定义来操作其派生类
public override Prototype Clone()
{
return (Prototype)this.MemberwiseClone(); //浅拷贝(shallow copy)
}
}
class ConcretePrototype2 : Prototype
{
public ConcretePrototype2(string id) //构造函数
: base(id)
{
}
//返回 Prototype 类型。在客户端程序中，依赖和获得的是 Prototype 抽象类，并以其定义来操作其派生类
public override Prototype Clone()
{
return (Prototype)this.MemberwiseClone(); //浅拷贝(shallow copy)
}
}
}
/*
执行结果：
Cloned: I
Cloned: II
*/
上方图 1 的 Class Diagram，以及「Shell (壳)」示例中，客户端程序透过抽象类 Prototype 的定义来操作其派生类。先选择一个「原型」实例，亦即 ConcretePrototype1 类或 ConcretePrototype2 类的实例，通过调用它所覆写抽象父类的 Clone 方法，获得一个和它一样、有相同 id 值的新对象，而非透过 new 运算符去创建实例。而拷贝完成后，拷贝的原型样本 (p1、p2)，和副本 (c1、c2) 是两个独立的对象，可以独立变化和修改。
但为什么不用 new 运算符加上某个类的构造函数去创建实例，而要再衍生出这种 Prototype Pattern 呢？其中一个原因，是系统设计上，类的种类可能会很多，而难以整合成特定的自定义类时；或类与类之间有大量平行阶层结构，类的数量过多会造成管理上的困难。例如本帖一开始提到的室内设计软件，桌子类和椅子类，又可各分成: 方形的、圆形的、其他各种形状的…，若全部都要写成不同的类，类的数量会很可观。
此外，也是为了避免整个系统中，类与类之间结构的剧烈变化，避免为了重载一个新的函数，导致我们要修改的不是一个类，而是整个继承关系体系里的每一个类。
另一个原因，是用户在用鼠标操作这个室内设计软件时 (运行时期)，若要重复创建相同的圆形桌子对象时，用 Prototype Pattern 这种对象复制的方式，由于对象初始化的内容都相同，会比从头用类去创建新的实例要容易，同时能在客户端程序中隐藏对象创建的细节，且在速度和性能上会较优 [15], [17]。
接下来的三个示例，为一个人事招聘系统的部分代码，我们以此为例来实现原型模式。某间公司要招聘「程序员」、「行政文员」两种职务，其中的 Employee 为顶层的抽象类，两个派生类 Developer 和 Typist 必须实现其 Clone 方法。示例执行结果如下图 3。
由于两个派生类 Developer 和 Typist，其成员都是 int 等「值类型」或 string，因此我们在客户端程序 (Page_Load) 中执行「浅拷贝」时，既有的第一个「原型」对象 - dev 和 typist 实例，其所有的字段，会被逐位复制到新对象 devCopy1、devCopy2、typistCopy1 中，且正本对象和副本对象的字段各自独立、存储在内存的不同位置。
此外，我们看到 Developer 第一个「拷贝」出来的对象 devCopy1，它的 Role、PreferredLanguage 字段，都和原型对象 dev 一样，是「资深工程师」和「C#」，而我们可以将 Name 字段改成「李大同」，而不影响原型对象 dev 的 Name 字段。
图 2 Sybase PowerDesigner 12.5 的「反向工程」功能，已可解析 C# 3.0 的 Auto-Implemented Property 语法
02_Employee / 01_ShallowCopy.aspx.cs
using System;
using com.cnblogs.WizardWu.Sample01;
//客户端程序
public partial class _01_ShallowCopy : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Developer dev = new Developer(); //原型对象(来自外部的第一个实例)
dev.Name = "王小明";
dev.Role = "资深工程师";
dev.PreferredLanguage = "C#";
Developer devCopy1 = (Developer)dev.Clone(); //浅拷贝(shallow copy)
devCopy1.Name = "李大同";
Developer devCopy2 = (Developer)dev.Clone(); //浅拷贝(shallow copy)
devCopy2.Name = "吴宇泽";
devCopy2.Role = "研发工程师";
devCopy2.PreferredLanguage = "C++";
Response.Write(dev + "
");
Response.Write(devCopy1 + "
");
Response.Write(devCopy2 + "
");
/* 执行结果：
王小明 - 资深工程师 - C#
李大同 - 资深工程师 - C#
吴宇泽 - 研发工程师 - C++
*/
Typist typist = new Typist(); //原型对象(来自外部的第一个实例)
typist.Name = "左婉青";
typist.Role = "行政文员";
typist.WordsPerMinute = 120;
Typist typistCopy1 = (Typist)typist.Clone(); //浅拷贝(shallow copy)
typistCopy1.Name = "周玉婷";
typistCopy1.WordsPerMinute = 115;
Response.Write(typist + "
");
Response.Write(typistCopy1 + "
");
/* 执行结果：
左婉青 - 行政文员 - 120 字/分
周玉婷 - 行政文员 - 115 字/分
*/
}
}
//服务器端程序
namespace com.cnblogs.WizardWu.Sample01
{
//员工 抽象类。
//每个具体的「原型」类，要实现的抽象类或接口
abstract class Employee
{
//返回 Employee 类型。
public abstract Employee Clone();
//.NET 3.0 的 Auto-Implemented Property (Automatic Properties) 语法，会自动产生对应的同名 private field
public string Name { get; set; } //姓名
public string Role { get; set; } //职务
}
//程序员
//继承 Employee 抽象类，或实现 .NET 的 ICloneable 接口，以便重写其 Clone 方法，创建作为当前实例副本的新对象
class Developer : Employee
{
public string PreferredLanguage { get; set; }
//返回 Employee 类型。在客户端程序中，依赖和获得的是 Prototype 抽象类，并以其定义来操作其派生类
public override Employee Clone()
{
return (Employee)MemberwiseClone(); //浅拷贝(shallow copy)。转型亦可用 as Employee
//return new Developer(); //深拷贝(deep copy)
}
public override string ToString()
{
return string.Format("{0} - {1} - {2}", Name, Role, PreferredLanguage);
}
}
//文员
//继承 Employee 抽象类，或实现 .NET 的 ICloneable 接口，以便重写其 Clone 方法，创建作为当前实例副本的新对象
class Typist : Employee
{
public int WordsPerMinute { get; set; }
//返回 Employee 类型。在客户端程序中，依赖和获得的是 Prototype 抽象类，并以其定义来操作其派生类
public override Employee Clone()
{
return (Employee)MemberwiseClone(); //浅拷贝(shallow copy)。转型亦可用 as Employee
//return new Typist(); //深拷贝(deep copy)
}
public override string ToString()
{
return string.Format("{0} - {1} - {2} 字/分", Name, Role, WordsPerMinute);
}
}
} //end of namespace
图 3 上方示例 01_ShallowCopy.aspx.cs 的执行结果。在两个派生类的 Clone 方法中，用 MemberwiseClone 方法实现了「浅拷贝」
接下来我们要把上方的示例，在派生类 Developer 中，添加一个「引用类型」的数组 int[] intArray。由于数组是「引用数型」，因此在做「浅拷贝」时，原始对象及其复本引用的是同一个对象 (指向内存的同一个位置)；当我们在 Page_Load 做完 Developer 的两次「浅拷贝」，再把最后一位程序员「吴宇泽」，他的 intArray 数组的第一个元素，其值从 1 改为 9，此时执行结果如下图 4 ，您会发现其他两位程序员 - 王小明、李大同，他们的 intArray 数组的第一个元素，也都同时被改成 9 了。
02_Employee / 02_ShallowCopy_fail.aspx.cs
using System;
using com.cnblogs.WizardWu.Sample02;
//客户端程序
public partial class _02_ShallowCopy_fail : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Developer dev = new Developer(); //原型对象(来自外部的第一个实例)
dev.Name = "王小明";
dev.Role = "资深工程师";
dev.PreferredLanguage = "C#";
Developer devCopy1 = (Developer)dev.Clone(); //浅拷贝(shallow copy)
devCopy1.Name = "李大同";
Developer devCopy2 = (Developer)dev.Clone(); //浅拷贝(shallow copy)
devCopy2.Name = "吴宇泽";
devCopy2.Role = "研发工程师";
devCopy2.PreferredLanguage = "C++";
Response.Write(dev + "
");
Response.Write(devCopy1 + "
");
Response.Write(devCopy2 + "
");
Response.Write(dev.Display() + "
");
Response.Write(devCopy1.Display() + "
");
Response.Write(devCopy2.Display() + "
");
//只将最后一个程序员「吴宇泽」，他的数组(引用类型) 的第一个元素，其值从 1 改为 9
devCopy2.intArray[0] = 9;
Response.Write(dev.Display() + "
");
Response.Write(devCopy1.Display() + "
");
Response.Write(devCopy2.Display() + "
");
/* 执行结果：
王小明 - 资深工程师 - C#
李大同 - 资深工程师 - C#
吴宇泽 - 研发工程师 - C++
1, 2, 3,
1, 2, 3,
1, 2, 3,
9, 2, 3,
9, 2, 3,
9, 2, 3,
*/
Typist typist = new Typist(); //原型对象(来自外部的第一个实例)
typist.Name = "左婉青";
typist.Role = "行政文员";
typist.WordsPerMinute = 120;
Typist typistCopy1 = (Typist)typist.Clone(); //浅拷贝(shallow copy)
typistCopy1.Name = "周玉婷";
typistCopy1.WordsPerMinute = 115;
Response.Write(typist + "
");
Response.Write(typistCopy1 + "
");
/* 执行结果：
左婉青 - 行政文员 - 120 字/分
周玉婷 - 行政文员 - 115 字/分
*/
}
}
//服务器端程序
namespace com.cnblogs.WizardWu.Sample02
{
//员工 抽象类。
//每个具体的「原型」类，要实现的抽象类或接口
abstract class Employee
{
//返回 Employee 类型。
public abstract Employee Clone();
//.NET 3.0 的 Auto-Implemented Property (Automatic Properties) 语法，会自动产生对应的同名 private field
public string Name { get; set; }
public string Role { get; set; }
}
//程序员
//继承 Employee 抽象类，或实现 .NET 的 ICloneable 接口，以便重写其 Clone 方法，创建作为当前实例副本的新对象
class Developer : Employee
{
public string PreferredLanguage { get; set; }
//多加一个「引用类型(Reference Type)」成员 - 数组(Array)
public int[] intArray = { 1, 2, 3 };
public string Display()
{
string strReturn = string.Empty;
foreach (int i in intArray)
{
strReturn += i.ToString() + ", ";
}
return strReturn;
}
public override Employee Clone()
{
return (Employee)MemberwiseClone(); //浅拷贝(shallow copy)。转型亦可用 as Employee
//return new Developer(); //深拷贝(deep copy)
}
public override string ToString()
{
return string.Format("{0} - {1} - {2}", Name, Role, PreferredLanguage);
}
}
//文员
//继承 Employee 抽象类，或实现 .NET 的 ICloneable 接口，以便重写其 Clone 方法，创建作为当前实例副本的新对象
class Typist : Employee
{
public int WordsPerMinute { get; set; }
public override Employee Clone()
{
return (Employee)MemberwiseClone(); //浅拷贝(shallow copy)。转型亦可用 as Employee
//return new Typist(); //深拷贝(deep copy)
}
public override string ToString()
{
return string.Format("{0} - {1} - {2} 字/分", Name, Role, WordsPerMinute);
}
}
} //end of namespace
图 4 Developer 类添加了一个「引用类型」的数组，造成「浅拷贝」时，只复制了「引用」，却未复制引用的字段
在下方的最后一个示例中，我们要更正前一个示例 02_ShallowCopy_fail.aspx.cs 的错误。我们把前述 Developer 类里面的 Clone 方法，从「浅拷贝」改成「深拷贝」，以搭配数组这个「引用类型」的拷贝；而另一个 Typist 类，由于没有「引用类型」成员，因此不需要更改，Clone 方法仍然延用「浅拷贝」。执行结果如下图 5，我们同样在 Page_Load 做 Developer 的两次拷贝，只不过这两次是「深拷贝」。结果符合我们需求，只有最后一位程序员「吴宇泽」，他的数组的第一个元素，其值从 1 改为 9，其他两位程序员则不受影响。
02_Employee / 03_DeepCopy.aspx.cs
using System;
using com.cnblogs.WizardWu.Sample03;
//客户端程序
public partial class _03_DeepCopy : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Developer dev = new Developer(); //原型对象(来自外部的第一个实例)
dev.Name = "王小明";
dev.Role = "资深工程师";
dev.PreferredLanguage = "C#";
Developer devCopy1 = (Developer)dev.Clone(); //深拷贝(deep copy)
devCopy1.Name = "李大同";
Developer devCopy2 = (Developer)dev.Clone(); //深拷贝(deep copy)
devCopy2.Name = "吴宇泽";
devCopy2.Role = "研发工程师";
devCopy2.PreferredLanguage = "C++";
Response.Write(dev + "
");
Response.Write(devCopy1 + "
");
Response.Write(devCopy2 + "
");
Response.Write(dev.Display() + "
");
Response.Write(devCopy1.Display() + "
");
Response.Write(devCopy2.Display() + "
");
//只将最后一个程序员「吴宇泽」，他的数组(引用类型) 的第一个元素，其值从 1 改为 9
devCopy2.intArray[0] = 9;
Response.Write(dev.Display() + "
");
Response.Write(devCopy1.Display() + "
");
Response.Write(devCopy2.Display() + "
");
/* 执行结果：
王小明 - 资深工程师 - C#
李大同 - 资深工程师 - C#
吴宇泽 - 研发工程师 - C++
1, 2, 3,
1, 2, 3,
1, 2, 3,
1, 2, 3,
1, 2, 3,
9, 2, 3,
*/
Typist typist = new Typist(); //原型对象(来自外部的第一个实例)
typist.Name = "左婉青";
typist.Role = "行政文员";
typist.WordsPerMinute = 120;
Typist typistCopy1 = (Typist)typist.Clone(); //浅拷贝(shallow copy)
typistCopy1.Name = "周玉婷";
typistCopy1.WordsPerMinute = 115;
Response.Write(typist + "
");
Response.Write(typistCopy1 + "
");
/* 执行结果：
左婉青 - 行政文员 - 120 字/分
周玉婷 - 行政文员 - 115 字/分
*/
}
}
//服务器端程序
namespace com.cnblogs.WizardWu.Sample03
{
//员工 抽象类。
//每个具体的「原型」类，要实现的抽象类或接口
abstract class Employee
{
//返回 Employee 类型。
public abstract Employee Clone();
//.NET 3.0 的 Auto-Implemented Property (Automatic Properties) 语法，会自动产生对应的同名 private field
public string Name { get; set; }
public string Role { get; set; }
}
//程序员
//继承 Employee 抽象类，或实现 .NET 的 ICloneable 接口，以便重写其 Clone 方法，创建作为当前实例副本的新对象
class Developer : Employee
{
public string PreferredLanguage { get; set; }
//多加一个「引用类型(Reference Type)」成员 - 数组(Array)
public int[] intArray = { 1, 2, 3 };
public string Display()
{
string strReturn = string.Empty;
foreach (int i in intArray)
{
strReturn += i.ToString() + ", ";
}
return strReturn;
}
public override Employee Clone()
{
//return (Employee)MemberwiseClone(); //浅拷贝(shallow copy)。转型亦可用 as Employee
//return new Developer(); //深拷贝(deep copy) - 做法一
//深拷贝(deep copy) - 做法二
Developer dev1 = new Developer(); //用 new 创建此类的实例
dev1.Name = this.Name;
dev1.Role = this.Role;
dev1.PreferredLanguage = this.PreferredLanguage;
return dev1;
}
public override string ToString()
{
return string.Format("{0} - {1} - {2}", Name, Role, PreferredLanguage);
}
}
//文员
//继承 Employee 抽象类，或实现 .NET 的 ICloneable 接口，以便重写其 Clone 方法，创建作为当前实例副本的新对象
class Typist : Employee
{
public int WordsPerMinute { get; set; }
public override Employee Clone()
{
return (Employee)MemberwiseClone(); //浅拷贝(shallow copy)。转型亦可用 as Employee
//return new Typist(); //深拷贝(deep copy)
}
public override string ToString()
{
return string.Format("{0} - {1} - {2} 字/分", Name, Role, WordsPerMinute);
}
}
} //end of namespace
图 5 将 Developer 类中 Clone 方法里的「浅拷贝」改成「深拷贝」，以配合该类中「引用类型」成员的复制
--------------------------------------------------------
Prototype Pattern 适用的情景：
- 当系统中，某个系列的类，变化和扩展特别频繁的时侯。
- 当系统应该独立于它的产品创建时。
- 想对客户端程序，隐藏类的具体内容。
- 希望依用户的操作，在「执行时期」动态地加载 (dynamic loading) 或动态获得对象的状态。例如本帖一开始提到的室内设计软件，会依使用者鼠标的操作来动态创建副本。
- 同上一点，当需要的类型不是编译时就能确定的，而是能在运行过程中动态选择的。
- 当类型本身可枚举的种类非常固定时，例如一家软件公司，只有「主管、程序员、业务员」三种职务，当公司标到大型项目，需要招幕一百个程序员，与其通过某种机制 new 一百个程序员实例，不如通过一个现成的「程序员」原型实例，克隆一百个对象出来。
- 当一个类的多个实例，他们之间的字段和属性只有些许不同时。
- 当一个类的实例，只能有几种不同状态组合的其中一种时。
- 当对象的初始化需要高成本，例如：构造函数的参数、字段数量很多很复杂时。
Prototype Pattern 的优点：
- 可达到资源优化，避免用 new 创建实例会较消耗资源，且这样做速度也比 clone 对象慢 [15], [17], [18]。
- 独立性和灵活性高，容易动态加载新功能。
- 减少类的数量。避免类的种类太多时，其子类数量会迅速地增加。
- 能在客户端程序中隐藏对象创建的细节。
Prototype Pattern 的缺点：
- 每一个类都需要配备并覆写 Clone 方法，且撰写时需要做整个系统架构的通盘考量。
Prototype Pattern 的其他特性：
- 可避免形成多个类与类之间的大量平行 (平级) 阶层结构，在宽度和深度上的扩展。
- 「浅拷贝」可以提供低成本的对象复制；但通过「序列化 (Serialization)」进行的「深拷贝」代价就比较大，而非低成本的。
--------------------------------------------------------
本帖的最后，提供一位 Java 大师 - 结城浩，所绘制的 Prototype Pattern 趣味四格漫画，原地址如下：
Giko 猫谈 DP 四格漫画：
http://www.javaworld.com.tw/jute/post/view?bid=44&id=40932&sty=3&age=0&tpg=1&ppg=1#40932
http://www.hyuki.com/dp/cat_Prototype.html
∧＿∧ 敲敲敲 ╱
（ ） ∧ ∧ ＜ 等于是利用 copy & paste 来制作实例..恩....。
（ ） (,,ﾟДﾟ) ╲＿＿＿＿＿＿＿＿＿＿＿＿
＿＿____ （つ＿つ＿＿__
｜ 日∇ ╲|ThinkPad|╲
｜ ========= ╲
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
＿＿＿＿＿＿＿＿＿＿＿＿
╱
| 喔~、是 Prototype Pattern 吗？
╲ ＿＿ ＿＿＿＿＿＿＿＿＿＿
|╱
∧＿∧ ╱
（ ・∀・） ∧ ∧ ＜ 你你是谁? ...有..有什么事嬷你？...
（ ⊃ ） (ﾟДﾟ；) ╲＿＿＿＿＿＿＿＿＿＿＿＿
＿＿______（つ＿つ＿＿__
｜ 日∇ ╲|ThinkPad|╲
｜ ========= ╲
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
＿＿＿＿＿＿＿＿＿＿
╱
| 利用实例来创建实例..恩
╲ ＿＿ ＿＿＿＿＿＿＿＿
|╱
∧＿∧ ╱
（ ・∀・） ∧ ∧ ＜ 恩..可以那样说...类变成配角.
（ ） (；ﾟДﾟ) ╲＿＿＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿ （つ＿つ＿＿__
｜ 日∇╲|ThinkPad|╲
｜ ========= ╲
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
＿＿＿＿＿＿＿＿＿＿
╱
| 把类的设计失败, 在实例去修正.恩.
╲ ＿＿ ＿＿＿＿＿＿＿＿
|╱
∧＿∧ ╱
（ ・∀・） ∧ ∧ ＜ 不..不是这样啦..
（ ⊃ ） (ﾟДﾟ；) ╲＿＿＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿（つ＿つ＿＿__
｜ 日∇ ╲|ThinkPad|╲
｜ ========= ╲
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
giko猫.clone()
∧ ∧ ┌────────────────
( ﾟДﾟ ) ＜ giko.clone()
U U └────────────────
| |
U U
∧ ∧ ∧ ┌────────────────
( ﾟД ﾟДﾟ ) ＜ 这这是、
U U U .└────────────────
| |
U U U
∧ ∧∧∧ ┌────────────────
( ﾟДﾟ ﾟДﾟ ) ＜ 到底到底是、
U U.U U └────────────────
| |
.U UU U
∧ ∧ ∧ ∧ ┌────────────────
( ﾟДﾟ ＞＜ ﾟДﾟ ) ＜ 是 shallow copy 是 shallow copy 吗
U U U U └────────────────
| ＞＜ |
.U U U U
. ∧ ∧ ∧ ∧ ┌────────────────
( ﾟДﾟ ) ＊ ( ﾟДﾟ ) ＜ 或是 deep copy。或是 deep copy。
U U U U └────────────────
| .| .＊ | |
U U .U U
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
--------------------------------------------------------
本帖的内容和四个示例，已过滤掉 Prototype Pattern 非必要的功能和角色，主要目的是让初学者能够快速入门。实务上 Prototype Pattern 还能有很多变化和进阶应用，比如：
- 整合「工厂模式」，用一个工厂类来单独负责构造的工作 [8], [19]。
- 通过「序列化 / 反序列化」实现深拷贝 [2], [13], [14], [20]。
- 客户端程序多通过一个 Prototype manager 去创建 ConcretePrototype 对象，避免客户端程序与 ConcretePrototype 类产生依赖 [4], [5], [14], [15], [20], [21]。
有兴趣深入研究的网友，可参阅下方的「相关文章」和「相关书籍」。
--------------------------------------------------------
相关文章:
[1] .NET深入学习笔记(4) 深拷贝与浅拷贝(Deep Copy and Shallow Copy) - 老徐的博客 - 博客园
http://www.cnblogs.com/frank_xl/archive/2009/02/24/1396903.html
[2] C# Tips 浅拷贝和深拷贝 - SQL SERVER - 数据库-数据仓库 - ZDNetChina中文社区
http://bbs.zdnet.com.cn/thread-1426176-1-1.html
[3] 小议 .NET 中的对象拷贝 - TerryLee's Tech Space - 博客园
http://terrylee.cnblogs.com/archive/2006/01/06/312493.html
(推荐此帖)
[4] C#设计模式（9）－Prototype Pattern - First we try, then we trust - 博客园
http://www.cnblogs.com/zhenyulu/articles/39257.html
[5] Prototype Design Pattern in C# and VB.NET (英文)
http://www.dofactory.com/Patterns/PatternPrototype.aspx
[6] Proxy 模式，作者: caterpillar (繁体中文)
http://caterpillar.onlyfun.net/Gossip/DesignPattern/PrototypePattern.htm
http://www.javaworld.com.tw/jute/post/view?bid=44&id=25500&sty=1&tpg=3&age=-1
[7] 原型模式(ProtoType) - 最简单的 - JavaEye技术网站
http://iwtxokhtd.javaeye.com/blog/361086
http://www.codeweblog.com/prototype-model-prototype/
[8] 设计模式学习笔记五——Prototype模式 - 每天进步一点点，微笑面对全世界！ - JavaEye技术网站
http://mybluesky99.javaeye.com/blog/384252
[9] Prototype Design Pattern :: BlackWasp Software Development (英文)
http://www.blackwasp.co.uk/Prototype.aspx
[10] 设计模式学习笔记（六）——Prototype原型模式 - KiddLee - 博客园
http://www.cnblogs.com/kid-li/archive/2006/05/18/403559.html
[11] Prototype pattern - Wikipedia, the free encyclopedia (英文)
http://en.wikipedia.org/wiki/Prototype_pattern
[12] DotNet Framework源代码中的模式（六）——Prototype（原型模式） - Guushuuse _NET - 博客园
http://www.cnblogs.com/guushuuse/archive/2009/05/15/1457951.html
[13] 无废话C#设计模式之五：Prototype - LoveCherry - 博客园
http://www.cnblogs.com/lovecherry/archive/2007/10/06/915535.html
[14] .NET设计模式（6）：原型模式（Prototype Pattern） - TerryLee's Tech Space - 博客园
http://www.cnblogs.com/Terrylee/archive/2006/01/16/317896.html
[15] ASP_NET Wiki Architecture Design Patterns (英文)
http://wiki.asp.net/page.aspx/499/prototype-pattern/
http://wiki.asp.net/page.aspx/276/design-patterns/
[16] Implementing Audit / history tracking using Prototype Pattern (英文)
http://www.codeproject.com/KB/aspnet/AuditTracking.aspx