原型模式的浅克隆和深克隆

本文转自：http://blog.csdn.net/liu_yujie2011com/article/details/40510567

一、是什么？

         浅拷贝：对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象

         深拷贝：对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制

         内部机制：

      （1）关于Object类的clone方法

         默认实现为“浅拷贝”，重写Object类中的clone方法。Java中所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域是protected类型的，一般的类无法调用，因此Prototype类需要将clone方法的作用域修改为public类型。

     （2）关于Java.lang.Cloneable接口

        在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。

二、怎么用？

   （一）浅拷贝

    浅拷贝运用：如果你改变一个非常基本类型的值时，原对象的值不要求改变时就用浅拷贝。就是一直处于覆盖的状态。例如：

[java] view plaincopyprint?

1. packagelc.clone.shadow;  
2. public classShadowClone implements Cloneable  
3. {  
4.     // 基本类型  
5.     private int a;  
6.     // 非基本类型  
7.     private String b;  
8.     // 非基本类型  
9.     private int[] c;  
10.     // 重写Object.clone()方法,并把protected改为public  
11.     @Override  
12.     public Object clone()  
13.     {  
14.         ShadowClone sc = null;  
15.         try  
16.         {  
17.             sc = (ShadowClone) super.clone();  
18.         } catch (CloneNotSupportedException e)  
19.         {  
20.             e.printStackTrace();  
21.         }  
22.         return sc;  
23.     }  
24.     public int getA()  
25.     {  
26.         return a;  
27.     }  
28.     public void setA(int a)  
29.     {  
30.         this.a = a;  
31.     }  
32.     public String getB()  
33.     {  
34.         return b;  
35.     }  
36.     public void setB(String b)  
37.     {  
38.         this.b = b;  
39.     }  
40.     public int[] getC()  
41.     {  
42.         return c;  
43.     }  
44.     public void setC(int[] c)  
45.     {  
46.         this.c = c;  
47.     }  
48. }  
49. 测试类Test.java  
50.    
51.    
52.    
53. packagelc.clone.shadow;  
54. public class Test  
55. {  
56.     public static void main(String[] args)throws CloneNotSupportedException  
57.     {  
58.         ShadowClone c1 = new ShadowClone();  
59.         //对c1赋值  
60.         c1.setA(100) ;  
61.         c1.setB("clone1") ;  
62.         c1.setC(new int[]{1000}) ;  
63.          
64.         System.out.println("克隆前: c1.a="+c1.getA() );  
65.         System.out.println("克隆前: c1.b="+c1.getB() );  
66.         System.out.println("克隆前: c1.c[0]="+c1.getC()[0]);  
67.        System.out.println("-----------") ;  
68.          
69.         //克隆出对象c2,并对c2的属性A,B,C进行修改  
70.          
71.         ShadowClone c2 = (ShadowClone)c1.clone();  
72.          
73.         //对c2进行修改  
74.         c2.setA(50) ;  
75.         c2.setB("clone2");  
76.         int []a = c2.getC() ;  
77.         a[0]=500 ;  
78.         c2.setC(a);  
79.          
80.         System.out.println("克隆后: c1.a="+c1.getA() );  
81.         System.out.println("克隆后: c1.b="+c1.getB() );  
82.         System.out.println("克隆后: c1.c[0]="+c1.getC()[0]);  
83.        System.out.println("---------------") ;  
84.          
85.         System.out.println("克隆后: c2.a=" + c2.getA());  
86.         System.out.println("克隆后: c2.b=" + c2.getB());  
87.         System.out.println("克隆后: c2.c[0]=" + c2.getC()[0]);  
88.     }  
89. }  
90. 结果:  
91. 克隆前: c1.a=100  
92. 克隆前: c1.b=clone1  
93. 克隆前: c1.c[0]=1000  
94. -----------  
95. 克隆后: c1.a=100  
96. 克隆后: c1.b=clone1  
97. 克隆后: c1.c[0]=500  
98. ---------------  
99. 克隆后: c2.a=50  
100. 克隆后: c2.b=clone2  
101. 克隆后: c2.c[0]=500  

[java] view plaincopyprint?

1. <span style="font-size: 14pt; font-family: SimSun; background-color: rgb(255, 255, 255);"> </span>  

    问题出现了,我指修改了克隆后的对象c2.c的值,但c1.c的值也改变了,与c2的值相等.以下针对浅克隆得出结论:基本类型是可以被克隆的,但引用类型只是copy地址,并没有copy这个地址指向的对象的值,这使得两个地址指向同一值,修改其中一个,当然另一个也就变了。

    由此可见,浅克隆只适合克隆基本类型,对于引用类型就不能实现克隆了。

（二）深拷贝

   利用序列化实现深度拷贝：

        把对象写到流里的过程是序列化(Serialization)过程；而把对象从流中读出来的过程则叫反序列化(Deserialization)过程。应当指出的是，写到流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

　    在Java语言里深度克隆一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的拷贝）写到一个流里（序列化），再从流里读回来（反序列化），便可以重建对象。

被克隆对象.DeepClone.java

[java] view plaincopyprint?

1. packagelc.clone.deep;  
2. importjava.io.Serializable;  
3. <span style="color:#cc0000;">//要实现深克隆必须实现Serializable接口</span>  
4. public classDeepClone implements Serializable  
5. {  
6.     private int a;  
7.     private String b;  
8.     private int[] c;  
9.     public int getA()  
10.     {  
11.         return a;  
12.     }  
13.     public void setA(int a)  
14.     {  
15.         this.a = a;  
16.     }  
17.     public String getB()  
18.     {  
19.         return b;  
20.     }  
21.     public void setB(String b)  
22.     {  
23.         this.b = b;  
24.     }  
25.     public int[] getC()  
26.     {  
27.         return c;  
28.     }  
29.     public void setC(int[] c)  
30.     {  
31.         this.c = c;  
32.     }  
33. }  
34. 测试类Test.java  
35.    
36. packagelc.clone.deep;  
37. importjava.io.ByteArrayInputStream;  
38. importjava.io.ByteArrayOutputStream;  
39. importjava.io.IOException;  
40. importjava.io.ObjectInputStream;  
41. importjava.io.ObjectOutputStream;  
42. public class Test  
43. {  
44.     public static void main(String[] args)throws CloneNotSupportedException  
45.     {  
46.         Test t = new Test();  
47.         DeepClone dc1 = new DeepClone();  
48.         // 对dc1赋值  
49.         dc1.setA(100);  
50.         dc1.setB("clone1");  
51.         dc1.setC(new int[] { 1000 });  
52.         System.out.println("克隆前: dc1.a=" + dc1.getA());  
53.         System.out.println("克隆前: dc1.b=" + dc1.getB());  
54.         System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);  
55.        System.out.println("-----------");  
56.         DeepClone dc2 = (DeepClone)t.deepClone(dc1);  
57.         // 对c2进行修改  
58.         dc2.setA(50);  
59.         dc2.setB("clone2");  
60.         int[] a = dc2.getC();  
61.         a[0] = 500;  
62.         dc2.setC(a);  
63.         System.out.println("克隆前: dc1.a=" + dc1.getA());  
64.         System.out.println("克隆前: dc1.b=" + dc1.getB());  
65.         System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);  
66.        System.out.println("-----------");  
67.         System.out.println("克隆后: dc2.a=" + dc2.getA());  
68.         System.out.println("克隆后: dc2.b=" + dc2.getB());  
69.         System.out.println("克隆后: dc2.c[0]=" + dc2.getC()[0]);  
70.     }  
71.    <span style="color:#cc0000;"> //用序列化与反序列化实现深克隆</span>  
72.     public Object deepClone(Object src)  
73.     {  
74.         Object o = null;  
75.         try  
76.         {  
77.             if (src != null)  
78.             {  
79.     <span style="color:#cc0000;">// 将对象写到流里</span>  
80.                 ByteArrayOutputStream baos =new ByteArrayOutputStream();  
81.                 ObjectOutputStream oos = newObjectOutputStream(baos);  
82.                 oos.writeObject(src);  
83.                 oos.close();  
84.    <span style="color:#cc0000;"> // 将对象从流里读出来</span>  
85.                 ByteArrayInputStream bais = newByteArrayInputStream(baos  
86.                         .toByteArray());  
87.                 ObjectInputStream ois = newObjectInputStream(bais);  
88.                 o = ois.readObject();  
89.                 ois.close();  
90.             }  
91.         } catch (IOException e)  
92.         {  
93.             e.printStackTrace();  
94.         } catch (ClassNotFoundException e)  
95.         {  
96.             e.printStackTrace();  
97.         }  
98.         return o;  
99.     }  
100. }  
101.    
102. 结果:  
103. 克隆前: dc1.a=100  
104. 克隆前: dc1.b=clone1  
105. 克隆前: dc1.c[0]=1000  
106. -----------  
107. 克隆前: dc1.a=100  
108. 克隆前: dc1.b=clone1  
109. 克隆前: dc1.c[0]=1000  
110. -----------  
111. 克隆后: dc2.a=50  
112. 克隆后: dc2.b=clone2  
113. 克隆后: dc2.c[0]=500<span style="font-size: 14pt; font-family: SimSun; background-color: rgb(255, 255, 255);"> </span>  

         深克隆后:修改dc1或者dc2,无论是基本类型还是引用类型,他们的值都不会随着一方改变另一方也改变。

         这样做的前提就是对象以及对象内部所有引用到的对象都是可序列化的，否则，就需要仔细考察那些不可序列化的对象可否设成transient，从而将之排除在复制过程之外。

　　浅拷贝显然比深拷贝更容易实现，因为Java语言的所有类都会继承一个clone()方法，而这个clone()方法所做的正式浅拷贝。

　　有一些对象，比如线程(Thread)对象或Socket对象，是不能简单复制或共享的。不管是使用浅拷贝还是深拷贝，只要涉及这样的间接对象，就必须把间接对象设成transient而不予复制；或者由程序自行创建出相当的同种对象，权且当做复制件使用。

三、对比

         通过以上对浅拷贝和深拷贝的简介，估计在脑子中已经了解了大概，接下来就通过对比来彻底消除对它们的疑惑吧！

         从上图中进行对比就可以明白其实质：浅拷贝指向的是同一个引用对象，而深拷贝指向的是两个完全一个样的引用对象。所以如果不想让引用对象跟着改变，就必须用深拷贝。如果只是单纯的值类型那么两者皆可以，那就在今后的项目中实践吧！

四、总结

         综上所述无论是浅拷贝还是深拷贝只要解决了问题就是好的拷贝，所以在今后的实践中要体会它们的价值，并让每个的价值都发挥最大化。