原型模式（Prototype Pattern）

原型模型:用于创建重复对象，同时保证性能。

这种模式实现一个原型接口，用于创建对象的克隆，当直接创建对象的代价比较大，则可以采用这种模式。例如：一个对象需要高代价的数据库操作之后被创建，这时可以缓存该对象，在下次请求时返回其克隆，不必在进行高代价的数据库操作。

下面将创建一个抽象类Pizza，再定义类PizzaCache，该类把Pizza对象存储在一个Hashtable中，并在请求的时候返回它们的克隆。

PrototypePatternDemo类使用PizzaCache来获取Pizza对象。

Pizza.java

public abstract class Pizza implements Cloneable {
private String name;
abstract void order();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}

CheesePizza.java

public class CheesePizza extends Pizza {
public CheesePizza() {
name = "CheesePizza";
}

public void order() {
System.out.println("Book a CheesePizza");
}
}

VeggiePizza.java

public class VeggiePizza extends Pizza {
public VeggiePizza() {
name = "VeggiePizza";
}

public void order() {
System.out.println("Book a VeggiePizza");
}
}

public class PizzaCache {
private static Hashtable<String, Pizza> PizzaMap = new Hashtable<String, Pizza>();

public static Pizza getPizza(String pizzaName) {
Pizza cache = PizzaMap.get(pizzaName);
return (Pizza) cache.clone();
}

public static void loadCache() {
CheesePizza cheesePizza = new CheesePizza();
PizzaMap.put(cheesePizza.getName(), cheesePizza);

VeggiePizza veggiePizza = new VeggiePizza();
PizzaMap.put(veggiePizza.getName(), veggiePizza);
}
}

public class PrototypePatternDemo {
public static void main(String[] args) {
PizzaCache.loadCache();

Pizza pizza1 = (Pizza) PizzaCache.getPizza("CheesePizza");
System.out.println("Pizza:" + pizza1.getName());

Pizza pizza2 = (Pizza) PizzaCache.getPizza("VeggiePizza");
System.out.println("Pizza:" + pizza2.getName());
}
}

与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。

拷贝的两种方式：

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

上面的例子实现的是浅拷贝。

浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。