原型模式的使用分析

原型模式是一种简单、易使用的创建型设计模式，通过给出一个原型对象来指明所创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身来创建一个新的实例。这样一来，通过原型实例创建新的对象，就不再需要关心这个实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法来获取新的对象，而无须再去通过new来创建。
原型模式的结构图如下所示：


原型模式的参与角色:
（1）客户角色：客户类提出创建对象的请求。
（2）抽象原型角色：这是一个抽象角色，通常由一个java接口或抽象类实现，具体原型都需要实现该接口。
（3）具体原型角色：客户端所需要的被复制的对象。
下面还是通过代码描述该模式的具体使用：
1、第一个文件：抽象原型文件Prototype.java
 

点击(此处)折叠或打开

1. /**
   
2.  * 抽象原型角色
   
3.  */
   
4. public abstract class Prototype implements Cloneable{
   
5. 
   
6.     /**
   
7.      * 克隆自身方法
   
8.      * @return
   
9.      */
   
10.     public Object clone() throws CloneNotSupportedException{
    
11.         return super.clone();
    
12.     }
    
13. }

2、第二个文件：具体原型文件ConcretePrototype1.java
 

点击(此处)折叠或打开

1. /**
   
2.  * 具体原型实现
   
3.  */
   
4. public class ConcretePrototype1 extends Prototype{
   
5. 
   
6.     public static int classFlag = 1;
   
7.     /**
   
8.      * 克隆自身方法
   
9.      * @return
   
10.      * @throws CloneNotSupportedException 
    
11.      */
    
12.     public Object clone() throws CloneNotSupportedException{
    
13.         return (ConcretePrototype1) super.clone();
    
14.     }
    
15. }

3、第三个文件：具体原型文件ConcretePrototype2.java
 

点击(此处)折叠或打开

1. /**
   
2.  * 具体原型实现
   
3.  */
   
4. public class ConcretePrototype2 extends Prototype{
   
5. 
   
6.     public static int classFlag = 2;
   
7.     /**
   
8.      * 克隆自身方法
   
9.      * @return
   
10.      * @throws CloneNotSupportedException 
    
11.      */
    
12.     public Object clone() throws CloneNotSupportedException{
    
13.         return (ConcretePrototype2) super.clone();
    
14.     }
    
15. }

 4、第四个文件：TestMain.java

点击(此处)折叠或打开

1. /**
   
2.  * 测试Main方法
   
3.  */
   
4. public class TestMain {
   
5. 
   
6.     public static void main(String [] args) throws CloneNotSupportedException{
   
7.         TestMain main = new TestMain();
   
8.         Prototype prototype1 = new ConcretePrototype1();
   
9.         ConcretePrototype1 concretePrototype1 = (ConcretePrototype1) prototype1.clone();
   
10.         System.out.println(concretePrototype1.classFlag);
    
11.         Prototype prototype2 = new ConcretePrototype2();
    
12.         ConcretePrototype2 concretePrototype2 = (ConcretePrototype2) prototype2.clone();
    
13.         System.out.println(concretePrototype2.classFlag);
    
14.     }
    
15. }

看了以上代码，大家可能会觉得原型模式其实还是挺简单的。
我们上面描述的对象创建方法是通过调用java中的clone方法来复制对象，我看到网上还有另外一种使用new的方式来创建对象，具体原型的写法如下所示。
 5、第一个文件：Prototype.java

点击(此处)折叠或打开

1. public interface Prototype{
   
2.     /**
   
3.      * 克隆自身的方法
   
4.      * @return 一个从自身克隆出来的对象
   
5.      */
   
6.     public Object clone();
   
7. }

6、第二个文件：ConcretePrototype1.java

点击(此处)折叠或打开

1. public class ConcretePrototype1 implements Prototype { 
   
2.     public Prototype clone() { 
   
3.         // 最简单的克隆，新建一个自身对象，由于没有属性就不再复制值了 
   
4.         Prototype prototype = new ConcretePrototype1(); 
   
5.         return prototype; 
   
6.     } 
   
7. }

7、第三个文件ConcretePrototype2.java
 

点击(此处)折叠或打开

1. public class ConcretePrototype2 implements Prototype {
   
2.     public Prototype clone(){
   
3.         //最简单的克隆，新建一个自身对象，由于没有属性就不再复制值了
   
4.         Prototype prototype = new ConcretePrototype2();
   
5.         return prototype;
   
6.     }
   
7. }

至于以上两种写法的区别就在于一种是直接调用clone方法实现浅克隆出一个对象，第二种是使用new，创建出一个完完全全独立的新对象，咱就把它称作是"深克隆"吧。
至于浅克隆和深克隆的区别是什么呢，简单的说：如果一个对象中只有基本类型属性，那深克隆和浅克隆效果都是一样的，基本类型数据不管是用深克隆还是浅克隆都会被克隆出一份，但如果对象中包含引用对象属性，那浅克隆其实这是拷贝了一份引用，而深克隆确实把整个引用对象都拷贝了一份。(大家可以参考下这篇帖子http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html）
在看了原型模式之后，大家可能会觉得这个跟工厂模式比较的相似。咱们把工厂模式的结构图也画一下，大家对比一下就知道的区别了。

比较明显原型模式没有工厂模式的抽象工厂和具体工厂的实现，代码结构要简单一些，当然你也可以把原型模式的抽象原型理解成一种特殊的工厂。
   8、原型模式的优点：
（1）根据客户端要求实现动态创建对象 ，客户端不需要知道对象的创建细节，便于代码的维护和扩展。
（2）使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。

（3） 原型模式类似于工厂模式，但它没有了工厂模式中的抽象工厂和具体工厂的层级关系，代码结构更清晰和简单。

9、原型模式的注意事项：
（1）使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不 会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为 private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的。
（2）在使用时要注意深拷贝与浅拷贝的问题。clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。