5.设计模式----prototype原型模式

原型模式：做到是原型，那肯定是自己本身才是原型，原型模式属于对象的创建模式。

　　　关于原型模式的实现方式分2种：

　　　　　　　　　（1）简单形式、（2）登记形式，这两种表现形式仅仅是原型模式的不同实现。

 package inter.method;
 /**
  * 提供一个具有复制本身的接口
  * @author zengrong
  *
  */
 public interface Prototype {

       public Object clone();
 }

 package impl.method;

 import inter.method.Prototype;

 public class ConcretePrototype1 implements Prototype {
     /**
      * 接口类对象使用了object，所有在复写时候，类型就随便都是可以的
      */
       public Prototype clone(){
             //最简单的克隆，新建一个自身对象，由于没有属性就不再复制值了
             Prototype prototype = new ConcretePrototype1();
             return prototype;
         }
 }

 package impl.method;

 import inter.method.Prototype;

 /**
  * 客户端
  * @author zengrong
  *
  */
 public class Client {

     /**
      * 需要创建的原型
      */

     private Prototype prototype;

     public Client( Prototype prototype){
         this.prototype=prototype;
     }
     /**
      * 创建原型
      */
     public void create () {
         Prototype cloneprototype = (Prototype) prototype.clone();
     }
 }

第二种原型模式：登记模式。就是价将原先进行实例的方式是客户端和原型直接联系，这样耦合性高，解决办法就是设置一个管理器进行来管理生成这些原型，

 package inter.pro.two;

 import java.util.HashMap;
 import java.util.Map;

 /**
  * 原型管理器
  * @author zengrong
  *，作为对所有原型对象的登记，
  *这个角色提供必要的方法，
  *供外界增加新的原型对象和取得已经登记过的原型对象。
  */
 public class PromManger {
         /**
          * 用来记录原型
          */
     private static Map<String,PrototypeTwo> map = new HashMap<String,PrototypeTwo>();

     private PromManger(){}//私有化构造

     /**
      * 设置一个方法来进行向原型集合中添加
      */
     public synchronized static void setPrototypes(String prototypeId,PrototypeTwo prototypeTwo) {
         map.put(prototypeId, prototypeTwo);

     }
      /**
      * 从原型管理器里面删除某个原型注册
      * @param prototypeId 原型编号
      */
     public synchronized static void removePrototype(String prototypeId){
         map.remove(prototypeId);
     }

     /**
      * 获取原型
      */
     public synchronized static  PrototypeTwo getPrototypeTwo( String prototypeId) {
         PrototypeTwo prototypeTwo = map.get(prototypeId);
         if(prototypeTwo==null){
             System.out.println("该原型还没有进行登记注册------无法获取---");
         }
         return prototypeTwo;
     }

 }

 package inter.pro.two;

 public class PrototypeCol implements PrototypeTwo {
         private String name;
         public PrototypeTwo clone(){
             PrototypeCol prototype = new PrototypeCol();
             prototype.setName(this.name);
             return prototype;
         }
         public String toString(){
             return "Now in Prototype1 , name = " + this.name;
         }
         @Override
         public String getName() {
             return name;
         }

         @Override
         public void setName(String name) {
             this.name = name;
         }
     }

 package inter.pro.two;
 /**
  *
  * @author zengrong
  *
  */
 public interface PrototypeTwo {
         /**
          * 具体的原型
          * @return
          */
         public PrototypeTwo clone();
         public String getName();
         public void setName(String name);

 }

简单原型和登记原型对比：

　　　　　　在原型数量很少的情况下，采用第一种方式，客户端呢保存原型，

　　　　　　但是在数量不确定的情况下，采用第二中方式，在复制一个原型对象之前，客户端可以查看管理员对象是否已经有一个满足要求的原型对象。如果有，可以直接从管理员类取得这个对象引用；如果没有，客户端就需要自行复制此原型对象。

在Java中有个方法和这个其实是一样的，Java中得克隆方法;

　　Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份

　　Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。

克隆满足的条件

clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：

　　（1）对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。

　　（2）对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。

　　（3）如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。

　　在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的。

在这里其实涉及到一个值传递和引用传递！