原型模式
网址链接：https://my.oschina.net/Sheamus/blog/384180
原型模式算是JAVA中最简单的设计模式了，原因是因为它已经被提供了语言级的支持，但是如果提到它的实现原理，又是最复杂的一个设计模式。
下面我们先来看看这个又简单又复杂的设计模式的定义。
定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
定义比较简单，总结一下是通过实例指定种类，通过拷贝创建对象。
在JAVA语言中使用原型模式是非常简单的，这是因为Object类当中提供了一个本地方法clone，而JAVA中的任何类只要实现了Cloneable标识接口，就可以使用clone方法来进行对象的拷贝。
我们写一个简单的实例来测试一下，很简单。
public class Prototype implements Cloneable {
private int x;
private int y;
private int z;
public Prototype() {
this.x = 2;
this.y = 3;
this.z = 4;
}
public void change() {
this.x = 9;
this.y = 8;
this.z = 7;
}
public Prototype clone() {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
throw new RuntimeException(exception);
}
return (Prototype) object;
}
public String toString() {
return "[" + x + "," + y + "," + z + "]";
}
public static void main(String[] args) {
Prototype prototype1 = new Prototype();
prototype1.change();
System.out.println(prototype1);
Prototype prototype2 = prototype1.clone();
System.out.println(prototype2);
}
}
输出结果：
[9,8,7]
[9,8,7]
从输出结果可以看出来，clone方法将prototype1复制了一个，然后赋给了prototype2，这就像复制粘贴一样。值得注意的是，在使用Object.clone()方法去拷贝一个对象时，构造方法是不被执行的，否则prototype2实例中x，y，z的值应该为2，3，4才对，如果你觉得不够直观，可以在构造方法里写一个输出语句试试。
从原型模式的使用方式不难推断出，原型模式常使用于以下场景：
1、对象的创建非常复杂，可以使用原型模式快捷的创建对象。
2、在运行过程中不知道对象的具体类型，可使用原型模式创建一个相同类型的对象，或者在运行过程中动态的获取到一个对象的状态。
对于clone方法，它执行的是浅拷贝，也就是说如果是引用类型的属性，则它不会进行拷贝，而是只拷贝引用。
看下面这个简单的测试，就能看出来了。
class Field{
private int a;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
}
public class ShallowPrototype implements Cloneable {
private int x;
private int y;
private int z;
private Field field;
public ShallowPrototype() {
this.x = 2;
this.y = 3;
this.z = 4;
this.field = new Field();
this.field.setA(5);
}
public Field getField() {
return field;
}
public ShallowPrototype clone() {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
throw new RuntimeException(exception);
}
return (ShallowPrototype) object;
}
public String toString() {
return "[" + x + "," + y + "," + z + "," + field.getA() + "]";
}
public static void main(String[] args) {
ShallowPrototype prototype1 = new ShallowPrototype();
System.out.println(prototype1);
System.out.println(prototype1.getField());
ShallowPrototype prototype2 = prototype1.clone();
System.out.println(prototype2);
System.out.println(prototype2.getField());
}
}
输出结果：
[2,3,4,5]
[2,3,4,5]
可以看到我们对ShallowPrototype拷贝以后，得到一个实例prototype2，不过当我们输出field属性时，发现它们是引用的同一个对象。这当然不是我们期望得到的结果，这种情况下，我们如果修改prototype1中field的属性a的值，则prototype2中的也会跟着改变。
然而如果要实现深度拷贝，则需要将实现了Cloneable接口并重写了clone方法的类中，所有的引用类型也全部实现Cloneable接口并重写clone方法，而且需要将引用类型的属性全部拷贝一遍。
下面是一个简单的深度拷贝的例子，由上面的例子更改得到。
class Field implements Cloneable{
private int a;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
protected Field clone() {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
throw new RuntimeException(exception);
}
return (Field) object;
}
}
public class DeepPrototype implements Cloneable {
private int x;
private int y;
private int z;
private Field field;
public DeepPrototype() {
this.x = 2;
this.y = 3;
this.z = 4;
this.field = new Field();
this.field.setA(5);
}
public Field getField() {
return field;
}
protected DeepPrototype clone() {
Object object = null;
try {
object = super.clone();
((DeepPrototype)object).field = this.field.clone();
} catch (CloneNotSupportedException exception) {
throw new RuntimeException(exception);
}
return (DeepPrototype) object;
}
public String toString() {
return "[" + x + "," + y + "," + z + "," + field.getA() + "]";
}
public static void main(String[] args) {
DeepPrototype prototype1 = new DeepPrototype();
System.out.println(prototype1);
System.out.println(prototype1.getField());
DeepPrototype prototype2 = prototype1.clone();
System.out.println(prototype2);
System.out.println(prototype2.getField());
}
}输出结果：
[2,3,4,5]
[2,3,4,5]
下面我们来看下原型模式的主要优点：
1、由于clone方法是由虚拟机直接复制内存块执行，所以在速度上比使用new的方式创建对象要快。
2、可以基于原型，快速的创建一个对象，而无需知道创建的细节。
3、可以在运行时动态的获取对象的类型以及状态，从而创建一个对象。
然而原型模式的缺点也是相当明显的，主要的缺点就是实现深度拷贝比较困难，需要很多额外的代码量。
不过实际当中我们使用原型模式时，也可以写一个基类实现Cloneable接口重写clone方法，然后让需要具有拷贝功能的子类继承自该类，这是一种节省代码量的常用方式。像上面的例子一样，如果一个类继承自Prototype，则会自动具有拷贝功能。
上一篇： 原型模式Prototype
下一篇： 原型模式（Prototype）