JAVA设计模式之 原型模式【Prototype Pattern】

标签：style   blog   http   io   color   ar   os   使用   java   

一、概述： 

    使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。简单的说就是对象的拷贝生成新的对象（对象的克隆），原型模式是一种对象创建型模式。

二、使用场景：

    创建新的对象可以通过对已有对象进行复制来获得，如果是相似对象，则只需对其成员变量稍作修改。

三、UML结构图：

四、参与者

(1)    Prototype（抽象原型类）：它是声明克隆方法的接口，是所有具体原型类的公共父类，可以是抽象类也可以是接口，甚至还可以是具体实现类。

(2)    ConcretePrototype（具体原型类）：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。

(3)    Client（客户类）：让一个原型对象克隆自身从而创建一个全新的对象。

五、用例学习：

1、抽象原型类：Prototype.java

[java] view plaincopy

1. /** 
2.  * 抽象原型类 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public abstract class Prototype {  
7.       
8.     /** 
9.      * 提供抽象克隆方法 
10.      */  
11.     public abstract Prototype clone();  
12.   
13. }  

2、具体原型类：ConcretePrototypeA.java

[java] view plaincopy

1. /** 
2.  * 具体原型类A 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ConcretePrototypeA extends Prototype {  
7.   
8.     /** 
9.      * 浅克隆 
10.      */  
11.     @Override  
12.     public Prototype clone() {  
13.         Prototype prototype = new ConcretePrototypeA();  
14.         return prototype;  
15.     }  
16.   
17. }  

3、客户端测试类：Client.java

[java] view plaincopy

1. public class Client {  
2.   
3.     public static void main(String[] args) {  
4.         Prototype prototypeA = new ConcretePrototypeA();  
5.         Prototype prototypeB = prototypeA.clone();  
6.           
7.         System.out.println(prototypeB.equals(prototypeA));   // return false  
8.         System.out.println(prototypeB == prototypeA);   // return false  
9.         System.out.println(prototypeB.getClass() == prototypeA.getClass());  // return true  
10.   
11.     }  
12.   
13. }  

这里我们可以看到 prototypeA对象克隆了一个对象prototypeB，但是prototypeA  != prototypeB， 说明prototypeB是一个全新的Prototype对象。

    注意：原型模式通过克隆方法所创建的对象是全新的对象，它们在内存中拥有新的地址，通常对克隆所产生的对象进行修改对原型对象不会造成任何影响，每一个克隆对象都是相互独立的。

六、扩展：

关于浅克隆与深克隆的简单介绍：

(1) 在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。如下Person对象：

[java] view plaincopy

1. public class Person {  
2. // 姓名  
3. private String name;  
4. // 年龄  
5. private int age;  
6. // 他的父亲  
7. private Father father;  
8. }  

name、age 为基本数据类型，father就为引用类型。

浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制

(2)浅克隆：

在Java语言中，通过覆盖Object类的clone()方法就是实现浅克隆，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制，也就是说原型对象只是将引用对象的地址复制一份给克隆对象，克隆对象和原型对象的引用类型成员变量还是指向相同的内存地址。

注意：能够实现克隆的Java类必须实现一个标识接口Cloneable，表示这个Java类支持被复制。如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常。

用代码说话：

1、引用对象：Father.java

[java] view plaincopy

1. public class Father{  
2.     // 姓名  
3.     private String name;  
4.     // 年龄  
5.     private int age;  
6.       
7.     public Father(String name, int age) {  
8.         this.name = name;  
9.         this.age = age;  
10.     }  
11.       
12.     public String getName() {  
13.         return name;  
14.     }  
15.     public void setName(String name) {  
16.         this.name = name;  
17.     }  
18.     public int getAge() {  
19.         return age;  
20.     }  
21.     public void setAge(int age) {  
22.         this.age = age;  
23.     }  
24.       
25. }  

2、克隆原型类: Person.java

[java] view plaincopy

1. public class Person implements Cloneable{  
2.     // 姓名  
3.     private String name;  
4.     // 年龄  
5.     private int age;  
6.     // 他的父亲  
7.     private Father father;  
8.   
9.     /** 
10.      * 重写 Object对象的clone方法实现Person对象的克隆 
11.      */  
12.     public Person clone(){  
13.         Object obj = null;  
14.         try {  
15.             obj = super.clone();  
16.             return (Person)obj;  
17.         } catch (CloneNotSupportedException e) {  
18.             e.printStackTrace();  
19.         }  
20.         return null;  
21.     }  
22.       
23.     public String getName() {  
24.         return name;  
25.     }  
26.   
27.     public void setName(String name) {  
28.         this.name = name;  
29.     }  
30.   
31.     public int getAge() {  
32.         return age;  
33.     }  
34.   
35.     public void setAge(int age) {  
36.         this.age = age;  
37.     }  
38.   
39.     public Father getFather() {  
40.         return father;  
41.     }  
42.   
43.     public void setFather(Father father) {  
44.         this.father = father;  
45.     }  
46. }  

3、测试类：CloneClient.java

[java] view plaincopy

1. public class CloneClient {  
2.   
3.     public static void main(String[] args) {  
4.         Father father = new Father("老子", 50);  
5.         Person son = new Person();  
6.         son.setName("儿子");  
7.         son.setAge(24);  
8.         son.setFather(father);  
9.           
10.         // 浅克隆出一个兄弟Person对象  
11.         Person brother = son.clone();  
12.         System.out.println(brother == son);  // return false  
13.         System.out.println(brother.getFather() == son.getFather());  // return true  
14.     }  
15.   
16. }  

以上 我们可以分析看到son 浅克隆出一个"兄弟"对象 brother，但是他们的引用对象"父亲"都是同一个对象，所有事实证明浅克隆没有对引用类型对象进行复制。

(3)深克隆：

    在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。

    那么如何实现深克隆呢？

    在Java语言中，如果需要实现深克隆，可以通过序列化(Serialization)等方式来实现。序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

用代码说话：

1、引用类：Father.java

[java] view plaincopy

1. import java.io.Serializable;  
2.   
3. public class Father implements Serializable{  
4.     // 姓名  
5.     private String name;  
6.     // 年龄  
7.     private int age;  
8.       
9.     public Father(String name, int age) {  
10.         this.name = name;  
11.         this.age = age;  
12.     }  
13.       
14.     public String getName() {  
15.         return name;  
16.     }  
17.     public void setName(String name) {  
18.         this.name = name;  
19.     }  
20.     public int getAge() {  
21.         return age;  
22.     }  
23.     public void setAge(int age) {  
24.         this.age = age;  
25.     }  
26.       
27. }  

2、克隆原型类: Person.java

[java] view plaincopy

1. import java.io.ByteArrayInputStream;  
2. import java.io.ByteArrayOutputStream;  
3. import java.io.IOException;  
4. import java.io.ObjectInputStream;  
5. import java.io.ObjectOutputStream;  
6. import java.io.OptionalDataException;  
7. import java.io.Serializable;  
8.   
9. public class Person implements Serializable{  
10.     // 姓名  
11.     private String name;  
12.     // 年龄  
13.     private int age;  
14.     // 他的父亲  
15.     private Father father;  
16.       
17.     /** 
18.      * 深克隆 
19.      * @return 
20.      * @throws IOException 
21.      * @throws ClassNotFoundException 
22.      * @throws OptionalDataException 
23.      */  
24.     public Person deepClone() throws IOException, ClassNotFoundException, OptionalDataException  
25.     {  
26.            //将对象写入流中  
27.            ByteArrayOutputStream bao=new  ByteArrayOutputStream();  
28.            ObjectOutputStream oos=new  ObjectOutputStream(bao);  
29.            oos.writeObject(this);  
30.             
31.            //将对象从流中取出  
32.            ByteArrayInputStream bis=new  ByteArrayInputStream(bao.toByteArray());  
33.            ObjectInputStream ois=new  ObjectInputStream(bis);  
34.            return  (Person) ois.readObject();  
35.     }  
36.       
37.     public String getName() {  
38.         return name;  
39.     }  
40.   
41.     public void setName(String name) {  
42.         this.name = name;  
43.     }  
44.   
45.     public int getAge() {  
46.         return age;  
47.     }  
48.   
49.     public void setAge(int age) {  
50.         this.age = age;  
51.     }  
52.   
53.     public Father getFather() {  
54.         return father;  
55.     }  
56.   
57.     public void setFather(Father father) {  
58.         this.father = father;  
59.     }  
60. }  

3、深克隆测试类：DeepCloneClient.java

[java] view plaincopy

1. public class DeepCloneClient {  
2.   
3.     public static void main(String[] args) {  
4.         Father father = new Father("老子", 50);  
5.         Person son = new Person();  
6.         son.setName("儿子");  
7.         son.setAge(24);  
8.         son.setFather(father);  
9.           
10.         try {  
11.             Person brother = son.deepClone();  
12.             System.out.println(brother == son);  // false  
13.             System.out.println(brother.getFather() == son.getFather());  // false  
14.               
15.         } catch (OptionalDataException e) {  
16.             e.printStackTrace();  
17.         } catch (ClassNotFoundException e) {  
18.             e.printStackTrace();  
19.         } catch (IOException e) {  
20.             e.printStackTrace();  
21.         }  
22.           
23.     }  
24.   
25. }  

以上我们可以分析看到通过深克隆出来的"兄弟"对象brother 和 son 不仅不等、就连他们的引用类型Father也不等啦。所有证明：通过深克隆 克隆出了一个完全独立的全新的对象。

JAVA设计模式之 原型模式【Prototype Pattern】

标签：style   blog   http   io   color   ar   os   使用   java   

原文地址：http://www.cnblogs.com/yuyanbian/p/4077712.html