创建模式--原型模式（JAVA）

原型模式：

原型模式主要针对模型对象类型的克隆，对已有构造好的对象进行复制获取一个新的对象实例。比如我们在获取一个对象并成功赋值后，要传递给多个处理类去处理。 打个比方：吃面是个处理类，面是个模型对象。我们将面从锅里煮熟（模型对象的赋值加工）出来后，分到好几个碗中（克隆）。然后再根据客户的要求对克隆出的面由不同的吃面对象再加工（放辣子，放醋，盐少等等），最后呈现到每个顾客面前的面就都不一样了。

表现形式：

　　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.....

结果

参考文摘：

《JAVA与模式》之原型模式（http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html）