Java Prototype模式(原型模式)

要理解原型原型模式必须先理解Java里的浅复制和深复制。有的地方，复制也叫做克隆。Java提供这两种克隆方式。

    浅克隆：被克隆对象的所有变量都含有与原来的对象相同的值，而它所有的对其他对象的引用都仍然指向原来的对象。换一种说法就是浅克隆仅仅克隆所考虑的对象，而不克隆它所引用的对象。

    深克隆：被克隆对象的所有变量都含有与原来的对象相同的值，但它所有的对其他对象的引用不再是原有的，而这是指向被复制过的新对象。换言之，深复制把要复制的对象的所有引用的对象都复制了一遍，这种叫做间接复制。深复制的源代码如下：   

Java代码  

1. public Object deepClone() throws IOException, OptionalDataException, ClassNotFoundException   
2.   
3.      {   
4.   
5.          //write to stream   
6.   
7.          ByteArrayOutputStream bo = new ByteArrayOutputStream();   
8.   
9.          ObjectOutputStream oo = new ObjectOutputStream(bo);   
10.   
11.          oo.writeObject(this);        //read from stream      ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());   
12.   
13.          ObjectInputStream oi = new ObjectInputStream(bi);   
14.   
15.            return (oi.readObject());   
16.   
17.      }  

public Object deepClone() throws IOException, OptionalDataException, ClassNotFoundException

     {

         //write to stream

         ByteArrayOutputStream bo = new ByteArrayOutputStream();

         ObjectOutputStream oo = new ObjectOutputStream(bo);

         oo.writeObject(this);        //read from stream      ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());

         ObjectInputStream oi = new ObjectInputStream(bi);

           return (oi.readObject());

     }

    Java语言的构建模型直接支持原型模型模式，所有要克隆的类必须实现一个标识接口Cloneable。所有的类都有一个Clone()方法(Object提供)。克隆满足的条件：对于任何对象x，都有x.clone()!=x，换言之，克隆的对象不是原来的对象；x.clone().getClass()==x.getClass(),换言之，克隆的对象与原对象是同一类型。x.clone().equals(x)成立。

Java代码  

1. public class Sheep implements Cloneable   
2.   
3.     {   
4.   
5.         private String name = "Dolly";   
6.   
7.         public Object clone() throws CloneNotSupportedException   
8.   
9.         {   
10.   
11.       return super.clone();   
12.   
13.         }   
14.   
15.     }  

public class Sheep implements Cloneable

    {

        private String name = "Dolly";

        public Object clone() throws CloneNotSupportedException

        {

      return super.clone();

        }

    }

原型模式定义: 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.

    Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

如何使用? 因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现一下子变得很简单.

以勺子为例：

Java代码  

1. public abstract class AbstractSpoon implements Cloneable   
2. {   
3.  String spoonName;   
4.   
5.  public void setSpoonName(String spoonName) {this.spoonName = spoonName;}   
6.  public String getSpoonName() {return this.spoonName;}   
7.   
8.  public Object clone()   
9.  {   
10.  Object object = null;   
11.  try {   
12.  object = super.clone();   
13.  } catch (CloneNotSupportedException exception) {   
14.  System.err.println("AbstractSpoon is not Cloneable");   
15.  }   
16.  return object;   
17.  }   
18. }   
19.  有个具体实现(ConcretePrototype):   
20.   
21. public class SoupSpoon extends AbstractSpoon   
22. {   
23.  public SoupSpoon()   
24.  {   
25.  setSpoonName("Soup Spoon");   
26.  }   
27. }  

public abstract class AbstractSpoon implements Cloneable
{
 String spoonName;

 public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
 public String getSpoonName() {return this.spoonName;}

 public Object clone()
 {
 Object object = null;
 try {
 object = super.clone();
 } catch (CloneNotSupportedException exception) {
 System.err.println("AbstractSpoon is not Cloneable");
 }
 return object;
 }
}
 有个具体实现(ConcretePrototype):

public class SoupSpoon extends AbstractSpoon
{
 public SoupSpoon()
 {
 setSpoonName("Soup Spoon");
 }
}

调用Prototype模式很简单:

AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon2 = spoon.clone();
当然也可以结合工厂模式来创建AbstractSpoon实例。

在Java中Prototype模式变成clone()方法的使用，由于Java的纯洁的面向对象特性，使得在Java中使用设计模式变得很自然，两者已经几乎是浑然一体了。这反映在很多模式上，如Interator遍历模式。