今天讲创建型设计模式中的原型模式，大家可以从标题中略微猜测一下，这个原型模式是个什么东东。
简介
定义：用原型实例创建对象的种类，然后通过复制这些原型创建新的实例。无须知道具体的创建细节。
动机：使用原型模式来复制一个对象，从而克隆出多个一模一样的对象。
说到这里大家应该明白了，这个原型模式其实就是克隆。当然克隆也有深克隆和浅克隆，下面举例子的时候我会说明的。
模型结构图：
说明：
Prototype：原型类定义Clone接口
ConcretePrototype：具体原型类
Client：客户端直接实例化或用工厂方法得到一个对象，然后调用clone方法得到多个对象。
为什么用克隆
现在有一个目标类：
public class Car {
public int size;
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
}
现在有一个复制对象的要求，并且不能改变原来的对象。一想用“=”不就完事了，之间用一个新引用指向这个对象，我们来看一下结果。
Car one = new Car();
one.setSize(10);
Car two = one;
System.out.println("one.getSize() = " + one.getSize());
System.out.println("two.getSize() = " + two.getSize());
测试一下输出：
one.getSize() = 10
two.getSize() = 10
哟，这不是成功了么？但是假如这么作：
two.setSize(200);
System.out.println("one.getSize() = " + one.getSize());
System.out.println("two.getSize() = " + two.getSize());
输出结果就变了：
one.getSize() = 200
two.getSize() = 200
所以没有满足需求，新的对象改变会影响到旧对象，那么这是为什么呢？用“=”赋值以后，现在的内存模型是这样的。
所以one和two指向同一个对象，修改的时候当然会影响另一方。
浅克隆
浅克隆就可以解决上述这个问题了，因为它克隆出来的是一个新的对象，和new不同的一点就是它的值和原型的值相同，这样可以省略初始化的步骤。
克隆的实质其实是重写对象的clone方法，我们知道Object类是所有类的父类，它有clone()方法的，那么我们的拷贝实质上是重写Object.clone()的。protected native Object clone() throws CloneNotSupportedException;。是否可以重写的关键就是实现Cloneable接口，这是一个标记接口（没有任何方法，仅起标记的作用），作用就是表明实现这个接口的类中，clone()方法是一个合法的拷贝函数；如果没有实现这个接口的话，调用对象的clone方法就会抛出CloneNotSupportedException。
浅拷贝举例：
public class Car implements Cloneable{
public int size;
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
在调用的时候：Car two = (Car)one.clone();因为返回的是Object对象，所以要进行强转。这样在执行向上面的语句：
two.setSize(200);
System.out.println("one.getSize() = " + one.getSize());
System.out.println("two.getSize() = " + two.getSize());
结果：
one.getSize() = 10
two.getSize() = 200
此时的内存模型指向是 这样的：
这样看起来任务圆满完成，新对象的修改不会影响旧对象，互不干涉。那么现在有多了新的需求，这个Car不光要有大小size，需要添加它的一些具体信息，比如型号，品牌，颜色等，信息类如下：
public class Information {
private String color;//颜色
private String name;//品牌
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
将信息类添加到Car中：
private Information inform;
public Information getInform() {
return inform;
}
public void setInform(Information inform) {
this.inform = inform;
}
测试一下：
Car one = new Car();
Information infor = new Information();
infor.setColor("blue");
infor.setName("BWM");
one.setSize(10);
one.setInform(infor);
Car two = (Car)one.clone();
System.out.println("one= " + one.toString());
System.out.println("two= " + two.toString());
two.setSize(200);
two.getInform().setName("benchi");
two.getInform().setColor("puple");
System.out.println("----------修改信息后-------------");
System.out.println("one= " + one.toString());
System.out.println("two= " + two.toString());
运行结果如下：
one= Car{size=10, color=blue, name=BWM}
two= Car{size=10, color=blue, name=BWM}
----------修改信息后-------------
one= Car{size=10, color=puple, name=benchi}
two= Car{size=200, color=puple, name=benchi}
我们可以看到，在修改two的时候影响到了one的信息，为什么会这样了。这就是深克隆和浅克隆的区别了，在执行clone方法的时候其实是将当前对象的属性拷贝到新对象，就是说这里干得是“=”得事情。那么如果是基本类型，没有什么问题，如果是引用得话，只是指向了同一个地址，而不拷贝对应得内存对象。
上述例子得内存模型是这样得：
丑不丑得问题就不谈了，理解inform其实指向同一个信息类就可以了。
深克隆
既然浅克隆不能解决问题，就使用深克隆。其实深克隆就是将类中得引用也拷贝一份就可以了，所以引用也要实现Cloneable接口。进行下面这样得修改。
信息类：
public class Information implements Cloneable{
......
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
Car类得clone方法要进行这样的改变：
protected Object clone() throws CloneNotSupportedException {
Car car = (Car)super.clone();
car.inform = (Information) inform.clone();
return car;
}
再次运行后结果如下：
one= Car{size=10, color=blue, name=BWM}
two= Car{size=10, color=blue, name=BWM}
----------修改信息后-------------
one= Car{size=10, color=blue, name=BWM}
two= Car{size=200, color=puple, name=benchi}
这个时候修改two就不会影响one了，圆满的完成了任务。此时的内存模型是这样滴：
问题：如果只是一个引用当然没什么问题了，这样写起来也挺简单的，如果现在是A引用B，B引用C，C引用D…这样所有的类都要实现Cloneable接口，并重写clone方法，太麻烦了。可以通过序列化，反序列化来实现这样的深拷贝。
序列化实现深拷贝
对象序列化是将对象写到流中，反序列化则是把对象从流中读取出来。写到流中的对象则是原始对象的一个拷贝，原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。
序列化的类必须要实现Serializable接口（标记接口），和Cloneable类似，目的就是声明该类可以合法的序列化。
将信息类改造一下class Information implements Serializable
就是声明一下接口，什么也不用干。
在Car中：
首先实现Serializable接口，其次增加myClone方法
public Object myClone() throws IOException, ClassNotFoundException {
//序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
//反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
外部调用的时候：
Car two = (Car)one.myClone();
结果如下：
one= Car{size=10, color=blue, name=BWM}
two= Car{size=10, color=blue, name=BWM}
----------修改信息后-------------
one= Car{size=10, color=blue, name=BWM}
two= Car{size=200, color=puple, name=benchi}
可以看出这样也使用了深拷贝。
那么如果有某一个信息不想被新的拷贝对象感知到，使用transient关键字修饰这个属性即可。
注：transient只能修饰属性，不能修饰方法。
只在序列化的时候起作用，clone的时候没用
应用场景
1、创建对象的成本比较大的时候。
2、系统需要保持对象的状态，对象的状态变化很小
3、避免创建一个同层次的工厂类
比如画图工具中，画一个圆只需要拖动工具栏里的圆即可，需要需要多个颜色和大小的圆，只需要复制多个再修改颜色和大小就可以了。
优点：快速创建很多相同或相似的对象，简化对象的创建过程。
缺点：1、使用clone。当引用很深的时候，克隆的调用链很长，代码复杂。
2、使用序列化。无法跨语言、序列化后码流很长、性能比较差
参考文章：
java克隆之深拷贝与浅拷贝
java序列化的缺点