原型模式是一个创建型模式。原型二字表明了该模式应该由一个样板实例，用户从这个样板对象中复制出一个内部属性一致的对象，这个过程也就是俗称的克隆。被复制的实例就是原型，这个原型是可定制的。原型模式多用于创建复杂的或者构造好事的实例，因为这种情况下，复制一个已经存在的实例比重新创建一个更高效。
综上总结一下，原型模式的定义就是：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
原型模式的使用场景：
- 类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗；
- 通过
new产生一个对象需要非常繁琐的数据准备或访问权限，这时可以使用原型模式； - 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝；
需要注意的是，通过实现Cloneable接口的原型模式再调用 clone 函数构造实例时并不一定比通过new操作速度快，只有当通过 new 构造对象较为耗时或成本较高时，通过 clone 方法才能够活的效率上的提升。因此再使用 Cloneable 时需要考虑构建对象的成本以及做一些效率上的测试。当然，实现原型模式也不一定非要实现 Cloneable 接口，也有其他的实现方式。
但是首先，我们还是使用 Cloneable 接口来实现一个原型模式，以便对原型模式有一个简单的理解：
import java.util.ArrayList;
import java.util.List;
public class Prototype implements Cloneable {
private String text;
private List<String> textList;
public Prototype() {
textList = new ArrayList<>();
}
@Override
public Prototype clone() throws CloneNotSupportedException {
Prototype prototype = (Prototype) super.clone();
prototype.text = this.text;
prototype.textList = this.textList;
return prototype;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public List<String> getTextList() {
return textList;
}
public void addToList(String text) {
this.textList.add(text);
}
@Override
public String toString() {
return "Prototype{" +
"text='" + text + '\'' +
", textList=" + textList +
'}';
}
}
上面是一个简单的原型模式，该类通过 clone 函数以实现对原型对象的克隆。特别注意的是，这个方法并不是 Cloneable 接口中的，二是 Object 中的方法。 Cloneable是一个标识接口，它表明这个类的对象是可拷贝的。如果没有实现 Cloneable 接口却调用了clone 函数将抛出异常，在这个示例中，我们通过实现 Cloneable 接口和覆写 clone 方法实现了原型模式。
下面我们进行一下测试：
Prototype prototype = new Prototype();
prototype.setText("the first class");
prototype.addToList("the first class in list");
Log.i("swifter", prototype.toString());
try {
Prototype second = prototype.clone();
second.setText("the second class");
second.addToList("the second class in list");
Log.i("swifter", second.toString());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
结果：
05-25 09:15:46.848 2544-2544/? I/swifter: Prototype{text='the first class', textList=[the first class in list]}
05-25 09:15:46.849 2544-2544/? I/swifter: Prototype{text='the second class', textList=[the first class in list, the second class in list]}
可见这种原型模式是没有问题的。至此，我们演示了原型模式的概念和一种实现方式。
但这里仍然会有一个问题：假如我们再此时再打印一下原型对象的话，就会发现如下结果：
05-25 09:39:01.278 3496-3496/lic.swifter.note.pattern.c4 I/swifter: Prototype{text='the first class', textList=[the first class in list]}
05-25 09:39:01.278 3496-3496/lic.swifter.note.pattern.c4 I/swifter: Prototype{text='the second class', textList=[the first class in list, the second class in list]}
05-25 09:39:01.278 3496-3496/lic.swifter.note.pattern.c4 I/swifter: Prototype{text='the first class', textList=[the first class in list, the second class in list]}
我们仅仅修改了克隆出来的兑现，为什么连原型对象也修改了呢？这就是在原型模式中很重要的浅拷贝和深拷贝了。
浅拷贝和深拷贝
我们都知道在 JAVA 中存在两种类型的数据：一种是基本数据类型（共有八种：char， byte，boolean，short，int，long，float，double），另一种就是引用数据类型了。对于引用数据类型，学过 C++ 的理解肯定会很深刻，因为这个东西非常像 C 或 C++ 中的指针类型，它并不包含所代表的对象的数据，而是一个地址，这个地址指向了这个对象。
那么对于这两种数据类型，深拷贝与浅拷贝又该怎么理解呢？很简单，只要理解了引用数据类型这两个概念就变得非常容易了：
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
举例来说更加清楚：对象A1中包含对B1的引用，B1中包含对C1的引用。浅拷贝A1得到A2，A2 中依然包含对B1的引用，B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2 中包含对C2（C1的copy）的引用。
那么理解了深浅拷贝这两个概念，那么结合上面所说的现象，我们很容易能够得出一个结论：
Object类里的clone()方法仅仅用于浅拷贝（拷贝基本成员属性，对于引用类型仅返回指向改地址的引用）
所以在进行拷贝时，我们就应该谨慎使用Object中的clone函数，因为其仅仅进行浅拷贝，在很多情况下不符合我们的要求。如果不经意使用了这个函数而又在其他地方更改了其中的引入数据，那么很有可能造成数据异常等业务上的问题。
那么我们应该如何进行深拷贝呢，说白了那就是在clone函数中多做一些事情，这些事情当然就是对引用数据对象的创建了。
举个例子，假如我们有如下的对象：
public class Person implements Cloneable{
private int age;
private String name;
public Person(Integer age, String name) {
super();
this.age = age;
this.name = name;
}
}
那么对于这个类的clone函数应该怎么写呢？我们知道age是基本数据类型，这个用Object的方法就能帮我们做了，那这个String类型的就需要我们操作了：
@Override
protected Object clone() throws CloneNotSupportedException {
Person person = super.clone();
person.name = new String(this.name);
return person;
}
