初学Java设计形式随记 - 原型(Prototype)模式
原型(Prototype)模式也有叫原始模型模式。
1. 用意：
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
2. 参与者：
•抽象原型（Prototype）： 声明一个克隆自身的接口。
•具体原型（Concrete Prototype）： 实现一个克隆自身的操作。
• 客户端（Client）：让一个原型克隆自身从而创建一个新的对象。
3.结构：
根据定义来看，原型模式就是用来复制对象的。
那么什么时候用原型模式呢？
还是用生产汽车的例子来理解。
首先，根据定义可以知道，原型模式是需要克隆自身的，那么，这就是说，必须有一个产品原型。
也就是说原型模式中的原型还是需要使用通过工厂方法，或其他方法先创建出来。
这么看来，原型模式是在生产多个相同或相似的产品对象的时候使用的。
那么，使用原型模式有什么优势呢？
假设生产一辆奥迪A6，可以考虑使用工厂模式（甚至建造者模式）。
1.如果我有了一辆奥迪A6，用的很不错，我的朋友也想要一辆，可是我们不知道是由哪家工厂生产的，不知道去哪购买。如果我的奥迪A6可以自己复制一辆，我的朋友是不是会很方便，甚至不用花钱了。（这是在做美梦呀！！）
使用原型模式，只要克隆它就可以了。
这样就不需要知道这个产品是由哪个工厂生产的，只要复制它，就可以快速的有一个新的产品对象了。
这样一来使得系统更加独立于产品的创建、构成和表示。因为它是由自己实现产品自身的创建的。
2.如果是需要再生产其他型号的汽车，例如奥迪A8。
在工厂模式中，我们通常需要再建一个奥迪A8的工厂。
因为奥迪A8和奥迪A6是一个产品等级的，如果克隆一个奥迪A6的产品对象，并修改一些属性，就可以创建出来新的产品对象奥迪A8。这样，就不需要新的工厂了。（厂家也在做美梦呢！！）
也就是说，这样避免了创建一个与产品类层次平行的工厂类层次。
由于使用原型模式，产品的创建过程更有独立性，不需要对应的工厂类，是产品内部的方法来创建的。所以，更容易动态地实现新产品类的增加和原有产品类的减少，不会对原有系统的结构造成影响。
怎么实现原型模式呢？
就是要实现原型的自我复制（克隆）。这就涉及到了浅克隆和深克隆的概念：（摘自阎宏的《Java与模式》）
1. 浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
2. 深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
3．利用串行化来做深复制
把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。
Java的clone（）方法：
clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。
Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。
Java中实现的代码：
浅复制（浅克隆）：
汽车类：
/*
* 汽车类
*
* 浅克隆（shadow clone）的实现
*/
public class Car implements Cloneable {
// 汽车款式
public int type;
// 引用的其他对象,汽车发动机
public Engine engine;
public Object clone() {
Object clone = null;
try {
// 这里只是克隆的自己本身
clone = super.clone();
// 为什么在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？
// 因为，在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，
// 将原始对象的内容一一复制到新对象的存储空间中。
} catch (CloneNotSupportedException e) {
}
return clone;
}
}
发动机类：
/*
* 汽车发动机类，汽车类中引用的对象的类
*/
public class Engine implements Cloneable {
// 汽车发动机型号
public int model;
}
客户端调用：
/*
* 浅克隆（shadow clone）的调用
*/
public class Client {
public static void main(String argv[])
{
System.out.println("-----创建汽车1-----");
Car car1=new Car();
car1.engine=new Engine();
car1.type=1;
car1.engine.model=1;
System.out.println("汽车1款式："+car1.type+"\t汽车1的发动机型号："+car1.engine.model);
System.out.println("----汽车1--克隆-->汽车2----");
Car car2=(Car)car1.clone();
car2.type=2;
car2.engine.model=2;
System.out.println("汽车2款式："+car2.type+"\t汽车2的发动机型号："+car2.engine.model);
System.out.println("汽车1款式："+car1.type+"\t汽车1的发动机型号："+car1.engine.model);
}
}
运行结果：
-----创建汽车1----- 汽车1款式：1 汽车1的发动机型号：1 ----汽车1--克隆-->汽车2---- 汽车2款式：2 汽车2的发动机型号：2 汽车1款式：1 汽车1的发动机型号：2
根据运行结果可以发现，浅复制（浅克隆）仅仅复制所考虑的对象，而不复制它所引用的对象。
所以，当设定汽车2的发动机型号为2 时，也将汽车1的发动机型号有1变成了2。
因为汽车1和汽车2实际上使用的是同一个发动机
深复制（深克隆）：
怎么实现深复制（深克隆）呢？修改一下汽车类和汽车发动机类：
汽车类：
/*
* 深克隆
*/
public class Car implements Cloneable {
public int type;
// 引用的其他对象
public Engine engine;
public Object clone() {
Car temp = null;
try {
// 先把自己本身复制
temp = (Car) super.clone();
// 为了实现深度克隆，需要将对其他对象（在这里是engine）的引用都复制过去。
temp.engine = (Engine) engine.clone();
} catch (CloneNotSupportedException e) {
// should never happen
}
return temp;
}
}
发动机类：
public class Engine implements Cloneable {
public int model;
/**
* 为了实现深度克隆，需要给在Lay1中被应用的对象lay2）也提供一个自己克隆自身的方法
*/
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
}
return clone;
}
}
客户端调用不变。
运行结果：
-----创建汽车1----- 汽车1款式：1 汽车1的发动机型号：1 ----汽车1--克隆-->汽车2---- 汽车2款式：2 汽车2的发动机型号：2 汽车1款式：1 汽车1的发动机型号：1
根据运行结果可以发现，深复制（深克隆）把要复制的对象所引用的对象都复制了一遍。
所以，当设定汽车2的发动机型号为2 时，汽车1的发动机型号还是1，没有变化。
因为，汽车1和汽车2拥有了两个不同的发动机。
利用串行化来做深复制（深克隆）：
汽车类
实现了串行（序列）化接口，并使用了在流中读取和写入对象。
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/*
* 汽车类
*
* 序列化的方式实现深克隆（deep clone）
*/
public class Car implements Serializable {
/**
* serialVersionUID
*/
private static final long serialVersionUID = 1859639569305572020L;
// 汽车款式
public int type;
// 引用的其他对象,汽车发动机
public Engine engine;
public Object clone() {
try {
// 将对象写到流里，把对象写到流里的过程是串行化（Serilization）过程
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo;
oo = new ObjectOutputStream(bo);
oo.writeObject(this);
// 从流里读出来，把对象从流中读出来的并行化（Deserialization）过程
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
return (oi.readObject());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
return null;
} catch (IOException e) {
// TODO Auto-generated catch block
return null;
}
}
}
汽车发动机类：
import java.io.Serializable;
public class Engine implements Cloneable, Serializable {
/**
* Car对象以及对象内部所有引用到的对象engine都是可串行化的
*/
private static final long serialVersionUID = -6228724315977120960L;
public int model;
}
客户端调用不变。
运行结果：
-----创建汽车1----- 汽车1款式：1 汽车1的发动机型号：1 ----汽车1--克隆-->汽车2---- 汽车2款式：2 汽车2的发动机型号：2 汽车1款式：1 汽车1的发动机型号：1
根据运行结果可以发现，通过串行化的方式也实现了深复制（可克隆）。
所以，当设定汽车2的发动机型号为2 时，汽车1的发动机型号还是1，没有变化。
因为，汽车1和汽车2拥有了两个不同的发动机。