原型模式：
用原型实例指定创建对象的种类，并且通过拷贝这种原型创建新的对象。（从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节）
使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
原型模式UML结构图：
对于深复制与浅复制（深拷贝与浅拷贝）的简单区别：
浅拷贝：只负责克隆按值传递的数据（比如基本数据类型、String类型），所有引用的对象仍然指向原来的对象，即修改该引用对象时修改的是最初的那个对象。
深拷贝：除了浅拷贝要克隆的值外，还负责克隆引用类型（属性的类型也是对象）的数据，即把引用对象的变量指向复制过的新对象，而不是，而不是原有被引用的对象，即修改该引用对象时不会影响最初的那个对象。
我们在执行Clone函数本身时，实际其内部实现是浅复制，当我们需要的属性值是引用对象并需要作出修改时，我们就应该采用深复制的手段（重写Clone函数，使得每一步都是浅复制）
例（原型模式基本代码）：
abstract class Prototype
{
private string id;
// Constructor
public Prototype(string id)
{
this.id = id;
}
// Property
public string Id
{
get { return id; }
}
public abstract Prototype Clone(); //关键在于此接口
}
class ConcretePrototype1 : Prototype
{
// Constructor
public ConcretePrototype1(string id)
: base(id)
{
}
public override Prototype Clone()
{
// Shallow copy
return (Prototype)this.MemberwiseClone(); //创建当前对象的浅复制副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，则对该字段执行逐位复制，如果该字段是引用类型，则复制其引用但是不复制引用的对象。
}
}
class ConcretePrototype2 : Prototype
{
// Constructor
public ConcretePrototype2(string id)
: base(id)
{
}
public override Prototype Clone()
{
// Shallow copy
return (Prototype)this.MemberwiseClone();
}
}
//Client:
ConcretePrototype1 p1 = new ConcretePrototype1("I");
ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
由于克隆实在太过常用，在.NET中System命名空间提供了ICloneable接口，其中唯一的方法就是Clone（），我们只需要实现这个接口就好了，就不用再新定义Prototype原型象类了。
例（简历复制——C#）：
//简历
class Resume : ICloneable
{
private string name;
private string sex;
private string age;
private string timeArea;
private string company;
public Resume(string name)
{
this.name = name;
}
//设置个人信息
public void SetPersonalInfo(string sex, string age)
{
this.sex = sex;
this.age = age;
}
//设置工作经历
public void SetWorkExperience(string timeArea, string company)
{
this.timeArea = timeArea;
this.company = company;
}
//显示
public void Display()
{
Console.WriteLine("{0} {1} {2}", name, sex, age);
Console.WriteLine("工作经历：{0} {1}", timeArea, company);
}
public Object Clone()
{
return (Object)this.MemberwiseClone();
}
}
上面的案例都是浅复制实现，如果我们涉及到引用对象时，就要采用深复制（有的时候引用里面嵌套这引用，导致引用有很多层，操作就会比较复杂，深复制需要深入到多少层需要事先就要考虑好，同时必须注意避免循环引用的问题，否则程序将会一直执行复制操作，陷入死循环）。
例（简历复制（深复制）——C#）：
//简历
class Resume : ICloneable
{
private string name;
private string sex;
private string age;
private WorkExperience work;
public Resume(string name)
{
this.name = name;
work = new WorkExperience();
}
private Resume(WorkExperience work) //提供给Clone函数调用的私有构造函数，以便克隆“工作经历”数据。
{
this.work = (WorkExperience)work.Clone(); //完成工作经历的内部克隆
}
//设置个人信息
public void SetPersonalInfo(string sex, string age)
{
this.sex = sex;
this.age = age;
}
//设置工作经历
public void SetWorkExperience(string workDate, string company)
{
work.WorkDate = workDate;
work.Company = company;
}
//显示
public void Display()
{
Console.WriteLine("{0} {1} {2}", name, sex, age);
Console.WriteLine("工作经历：{0} {1}", work.WorkDate, work.Company);
}
public Object Clone()
{
Resume obj = new Resume(this.work); //调用私有的构造方法，让工作经历克隆完成，然后再给这个“简历”对象相关字段赋值，最终返回一个深复制的简历对象。
obj.name = this.name;
obj.sex = this.sex;
obj.age = this.age;
return obj;
}
}
//工作经历
class WorkExperience : ICloneable
{
private string workDate;
public string WorkDate
{
get { return workDate; }
set { workDate = value; }
}
private string company;
public string Company
{
get { return company; }
set { company = value; }
}
public Object Clone()
{
return (Object)this.MemberwiseClone();
}
}
在某些特定场合，会经常用到深复制和浅复制，比如在数据集对象DataSet，就有Clone（）方法和Copy（）方法，Clone（）方法用来复制DataSet的结构但是不复制数据，实现了原型模式的浅复制，Copy（）方法不但复制结构也复制数据，其实就是实现了原型模式的深复制。
Prototype模式与Factory模式的关系 ：
虽然原型引入的初衷是像上面所说，但实现起来，却完全可以达到工厂模式的效果；而且，用起来甚至比工厂模式更方便、灵活。对于工厂模式与原形模式在功能上 的这点巧合，也许是因为本来工厂模式和 原型模式都是创建型模式，这样，他们的基本功能都能生成对象，因而使得原型模式在功能上可以代替工厂模式。
在原型模式中，你完全可以同样定义一个这样的 “抽象产品——具体产品”层次，再利用具体产品本身的clone功能来产生具体产品本身。从而达到实现工厂模 式功能的目的。实际上，在原型模式中，每个具体产品就扮演了工厂模 式里的具体工厂的角色（因为每个具体产品都具有生成自己拷贝的功能，从这种意义上讲，这正是工厂的作用）。
原型模式提供了简化的创建结构。工厂方法模式常常需要有一个与产品类等级结构相同的等级结构，而原型模式就不需要这样。
Prototype模式的最主要缺点就是每个原 型的子类都必须实现clone的操作，尤其在包含引用类型的对象时，clone方法会比较麻烦，必须要能够递归地让所有的相关对象都要正确地实现克隆。
下面我们对上面的内容强化练习一下（这次我们采用Java版本）：
例（订单处理系统（深复制）——Java）：
现在有一个订单处理系统，里面有一个保存订单的业务 功能，需求：每当订单的预定产品数量超过1000的时候，就需要把订单拆成两份订单来保存。如果拆成两份后还是超过1000，则继续拆分，直到每份产品预订数量不超过1000。
根据业务，目前的订单系统分成两种，一种是个人订单、一种是公司订单。
客户名称、产品对象（ID，Name），订购产品数量。
公司名称、产品对象（ID，Name），订购产品数量。
UML图：
//Product(产品类):
/*
* 浅克隆（浅复制）是对要克隆的对象，其中的基本类型复制一份新的产生给对象。但是对于非基本类型的数据类型，仅仅是复制一份引用给新产生的对象。
* 即基本类型是新产生的，非基本类型是复制一份内存引用。
*
* 实现步骤：
* 1.实现Cloneable接口
* 要clone方法，为什么还要实现Cloneable接口呢？我们可以看看，Cloneable其中是一个空方法，它和RandomAccess一样都属于，标识接口。
* 针对的是Object里的clone方法，进行重写。告诉Object而已。
* 如果调用了super.clone()方法。没有实现Cloneable接口。那么会抛出异常CloneNotSupportedException异常。
*
* 2.重写clone方法。
* JDK中的API文档也说明了，这是一个对象拷贝的过程，不是对象的初始化过程。他包含了一些原有对象的信息。
* Object中的clone的返回值是native。
* native属于一般是由C语言实现，效率一般都高于java代码，所以这里我们没有选择new一个新的对象，而是选择对象拷贝。
*
* Object中的clone修饰符是protected，我们要把它改成public。
*/
/*
* 深度克隆，其实就是对于浅度克隆的一种完善，浅度克隆只能完成基本类型的克隆，对于非基本类型无法克隆，只能复制内存地址到新的对象上。
* 而深度克隆不同，深度克隆是完成了，基本数据类型和非基本数据类型，都可以克隆。
* 深复制重点在于：在主类上添加子类的Clone方法。（即多层浅复制）
*/
public class Product implements Cloneable {
private int ID;
private String name;
public Product() {
super();
}
public Product(int iD, String name) {
super();
ID = iD;
this.name = name;
}
public int getID() {
return ID;
}
public void setID(int iD) {
ID = iD;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Object clone() throws CloneNotSupportedException {
//数据类型都是基本数据类型，执行浅复制
return super.clone();
}
@Override
public String toString() {
return " ID："+ID+" Name："+name;
}
}
//Order（订购顺序）：
public class Order implements Cloneable {
private int num;
private String name;
private Product product;
public Order() {
super();
}
public Order(int num, String name, Product product) {
super();
this.num = num;
this.name = name;
this.product = product;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
@Override
public Object clone() throws CloneNotSupportedException {
//首层浅复制
Order order = (Order) super.clone();
//相对于order的深复制（相对于product的浅复制）
//深复制实质是多层浅复制
order.setProduct((Product)product.clone());
return order;
}
@Override
public String toString() {
return "订单数目："+num+" 订单类型："+name+product.toString();
}
}
//main:
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
int MAX=1000;
List<Order> list = new ArrayList<Order>();
Product product = new Product(1, "产品1");
Order order = new Order(3000,"公司订单",product);
int y=order.getNum();
while (y>MAX) {
Order tmp = (Order) order.clone();
tmp.setNum(MAX);
list.add(tmp);
y=order.getNum()-MAX;
order.setNum(y);
}
list.add(order);
System.out.println("共有"+list.size()+"份订单");
for (int i=0; i<list.size(); i++) {
System.out.println(list.get(i).toString());
}
}
}