原型模式：
原型模式主要针对模型对象类型的克隆，对已有构造好的对象进行复制获取一个新的对象实例。比如我们在获取一个对象并成功赋值后，要传递给多个处理类去处理。 打个比方：吃面是个处理类，面是个模型对象。我们将面从锅里煮熟（模型对象的赋值加工）出来后，分到好几个碗中（克隆）。然后再根据客户的要求对克隆出的面由不同的吃面对象再加工（放辣子，放醋，盐少等等），最后呈现到每个顾客面前的面就都不一样了。
表现形式：
1. 简单形式
2. 登记形式
1.简单形式
浅克隆要实现cloneable接口，因克隆是Object的一个native方法，因此父类要重新复写clone方法，调用object的native的clone。因此可自建一个所有原型类的抽象类或者接口，防止原型类未复写clone方法而无法克隆本体。如果对象中套用对象需要在clone中对套用的对象再进行clone，如果对复杂的对象就要用流形式深拷贝，需要实现Serialized接口。
详见：深拷贝和浅拷贝（http://www.cnblogs.com/DennyZhao/p/7016528.html）
public abstract class BaseProtoType implements Cloneable {
/**
*不能用抽象方法，clone最终调用Object的clone
*/
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
BaseProtoType
public interface Noddles {
public int longer();
public int stronger();
public void setDelicate(String str);
}
Noddles
public class NoddlesProtoType extends BaseProtoType implements Noddles{
private int longer;
private int stronger;
@Override
public int longer() {
System.out.println("---lonnger-----" + this.longer);
return this.longer;
}
@Override
public int stronger() {
System.out.println("---stronger-----" + this.stronger);
return this.stronger;
}
@Override
public void setDelicate(String str) {
System.out.println("---delicate-----" + str);
}
public int getLonger() {
return longer;
}
public void setLonger(int longer) {
this.longer = longer;
}
public int getStronger() {
return stronger;
}
public void setStronger(int stronger) {
this.stronger = stronger;
}
}
NoddlesProtoType
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, CloneNotSupportedException {
NoddlesProtoType noddles = new NoddlesProtoType();
noddles.setLonger(4);
noddles.setStronger(8);
Noddles noddles2 = (Noddles)noddles.clone();
noddles2.longer();
noddles2.stronger();
noddles2.setDelicate("salt");
Noddles noddles3 = (Noddles)noddles.clone();
noddles3.longer();
noddles3.stronger();
noddles3.setDelicate("chilli");
}
测试方法
运行结果：
---lonnger-----4
---stronger-----8
---delicate-----salt
---lonnger-----4
---stronger-----8
---delicate-----chilli
2. 登记形式
将多个类的克隆由一个管理类统一管理，注册，克隆。
package pattern.creation.factory; import java.util.HashMap;
import java.util.Map; /**
* 这种管理器只能有一个，因此采用单例模式
*
* @author DennyZhao
* @date 2017年6月20日
* @version 1.0
*/
public class PrototypeManager { private Map<String, BaseProtoType> map = new HashMap<String, BaseProtoType>(); private static PrototypeManager propoManager = null;
/**
* 私有化
*/
private PrototypeManager(){ } /**
* 创建实例方法
* @return
*/
public static PrototypeManager newInstance(){
if(propoManager == null){
synchronized(PrototypeManager.class){
if(propoManager == null){
propoManager = new PrototypeManager();
}
}
}
return propoManager;
} /**
* 存放键值对
* @param key
* @param value
*/
public void setProtoType(String key, BaseProtoType value){
map.put(key, value);
} /**
* 获取克隆后的对象
* @param key
* @return
* @throws CloneNotSupportedException
*/
@SuppressWarnings("unchecked")
public <T> T getCloneProtoType(String key) throws CloneNotSupportedException{
BaseProtoType baseProtoType = map.get(key);
if(baseProtoType == null){
return null;
}
return (T)baseProtoType.clone();
}
}
PrototypeManager
PrototypeManager manager = PrototypeManager.newInstance();
NoddlesProtoType noddles = new NoddlesProtoType();
noddles.setStronger(5);
noddles.setDelicate("It's delicious..");
noddles.setLonger(8);
RiceProtoType rice = new RiceProtoType();
rice.setWater("I need more water.....");
manager.setProtoType("noddle", noddles);
manager.setProtoType("rice", rice);
NoddlesProtoType cloneNoddles = manager.getCloneProtoType("noddle");
RiceProtoType cloneRice = manager.getCloneProtoType("rice");
System.out.println("-------------");
cloneNoddles.longer();
cloneRice.getWater();
测试
---delicate---------delicate
-------------
---lonnger-----8
--water-----I need more water.....
结果
参考文摘：