java实现shadow clone(浅克隆)与深克隆(deep clone)

最近在学习设计模式中的prototype(原型)模式,提出了浅克隆与深克隆,当时甚是不解.于是在网上找了些资料,研究一下,才顿开茅塞.以下是笔人的一点小经验,可提供大家参考,不到之处还请大家点评.

 

克隆就是复制一个对象的复本.但一个对象中可能有基本数据类型,如:int,long,float    等,也同时含有非基本数据类型如(数组,集合等)
被克隆得到的对象基本类型的值修改了,原对象的值不会改变.这种适合shadow clone(浅克隆).

但如果你要改变一个非基本类型的值时,原对象的值却改变了,.比如一个数组,内存中只copy他的地址,而这个地址指向的值并没有copy,当clone时,两个地址指向了一个值,这样一旦这个值改变了,原来的值当然也变了,因为他们共用一个值.,这就必须得用深克隆(deep clone)

以下举个例子,说明以上情况.

被克隆类:ShadowClone.java

1. package lc.clone.shadow;
3. public class ShadowClone implements Cloneable
4. {
5.     // 基本类型
6.     private int a;
7.     // 非基本类型
8.     private String b;
9.     // 非基本类型
10.     private int[] c;
12.     // 重写Object.clone()方法,并把protected改为public
13.     @Override
14.     public Object clone()
15.     {
16.         ShadowClone sc = null;
17.         try
18.         {
19.             sc = (ShadowClone) super.clone();
20.         } catch (CloneNotSupportedException e)
21.         {
22.             e.printStackTrace();
23.         }
24.         return sc;
25.     }
27.     public int getA()
28.     {
29.         return a;
30.     }
32.     public void setA(int a)
33.     {
34.         this.a = a;
35.     }
37.     public String getB()
38.     {
39.         return b;
40.     }
42.     public void setB(String b)
43.     {
44.         this.b = b;
45.     }
47.     public int[] getC()
48.     {
49.         return c;
50.     }
52.     public void setC(int[] c)
53.     {
54.         this.c = c;
55.     }
57. }

测试类Test.java

 

1. package lc.clone.shadow;
3. public class Test
4. {
6.     public static void main(String[] args) throws CloneNotSupportedException
7.     {
9.         ShadowClone c1 = new ShadowClone();
10.         //对c1赋值
11.         c1.setA(100) ;
12.         c1.setB("clone1") ;
13.         c1.setC(new int[]{1000}) ;
14.         
15.         System.out.println("克隆前: c1.a="+c1.getA() );
16.         System.out.println("克隆前: c1.b="+c1.getB() );
17.         System.out.println("克隆前: c1.c[0]="+c1.getC()[0]);
18.         System.out.println("-----------") ;
19.         
20.         //克隆出对象c2,并对c2的属性A,B,C进行修改
21.         
22.         ShadowClone c2 = (ShadowClone) c1.clone();
23.         
24.         //对c2进行修改
25.         c2.setA(50) ;
26.         c2.setB("clone2");
27.         int []a = c2.getC() ;
28.         a[0]=500 ;
29.         c2.setC(a);
30.         
31.         System.out.println("克隆后: c1.a="+c1.getA() );
32.         System.out.println("克隆后: c1.b="+c1.getB() );
33.         System.out.println("克隆后: c1.c[0]="+c1.getC()[0]);
34.         System.out.println("---------------") ;
35.         
36.         System.out.println("克隆后: c2.a=" + c2.getA());
37.         System.out.println("克隆后: c2.b=" + c2.getB());
38.         System.out.println("克隆后: c2.c[0]=" + c2.getC()[0]);
40.     }
42. }

结果:
克隆前: c1.a=100
克隆前: c1.b=clone1
克隆前: c1.c[0]=1000
-----------
克隆后: c1.a=100
克隆后: c1.b=clone1
克隆后: c1.c[0]=500
---------------
克隆后: c2.a=50
克隆后: c2.b=clone2
克隆后: c2.c[0]=500

 

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

那如何实现克隆引用对象呢,以下提供一种方法.    用序列化与反序列化实现深克隆(deep copy)

被克隆对象.DeepClone.java

 

1. package lc.clone.deep;
3. import java.io.Serializable;
5. //要实现深克隆必须实现Serializable接口
6. public class DeepClone implements Serializable
7. {
8.     private int a;
9.     private String b;
10.     private int[] c;
12.     public int getA()
13.     {
14.         return a;
15.     }
17.     public void setA(int a)
18.     {
19.         this.a = a;
20.     }
22.     public String getB()
23.     {
24.         return b;
25.     }
27.     public void setB(String b)
28.     {
29.         this.b = b;
30.     }
32.     public int[] getC()
33.     {
34.         return c;
35.     }
37.     public void setC(int[] c)
38.     {
39.         this.c = c;
40.     }
42. }

测试类Test.java

 

1. package lc.clone.deep;
3. import java.io.ByteArrayInputStream;
4. import java.io.ByteArrayOutputStream;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
9. public class Test
10. {
12.     public static void main(String[] args) throws CloneNotSupportedException
13.     {
14.         Test t = new Test();
15.         DeepClone dc1 = new DeepClone();
16.         // 对dc1赋值
17.         dc1.setA(100);
18.         dc1.setB("clone1");
19.         dc1.setC(new int[] { 1000 });
21.         System.out.println("克隆前: dc1.a=" + dc1.getA());
22.         System.out.println("克隆前: dc1.b=" + dc1.getB());
23.         System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);
24.         System.out.println("-----------");
26.         DeepClone dc2 = (DeepClone) t.deepClone(dc1);
27.         // 对c2进行修改
28.         dc2.setA(50);
29.         dc2.setB("clone2");
30.         int[] a = dc2.getC();
31.         a[0] = 500;
32.         dc2.setC(a);
34.         System.out.println("克隆前: dc1.a=" + dc1.getA());
35.         System.out.println("克隆前: dc1.b=" + dc1.getB());
36.         System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);
37.         System.out.println("-----------");
39.         System.out.println("克隆后: dc2.a=" + dc2.getA());
40.         System.out.println("克隆后: dc2.b=" + dc2.getB());
41.         System.out.println("克隆后: dc2.c[0]=" + dc2.getC()[0]);
43.     }
45.     // 用序列化与反序列化实现深克隆
46.     public Object deepClone(Object src)
47.     {
48.         Object o = null;
49.         try
50.         {
51.             if (src != null)
52.             {
53.                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
54.                 ObjectOutputStream oos = new ObjectOutputStream(baos);
55.                 oos.writeObject(src);
56.                 oos.close();
58.                 ByteArrayInputStream bais = new ByteArrayInputStream(baos
59.                         .toByteArray());
60.                 ObjectInputStream ois = new ObjectInputStream(bais);
62.                 o = ois.readObject();
63.                 ois.close();
64.             }
66.         } catch (IOException e)
67.         {
68.             e.printStackTrace();
69.         } catch (ClassNotFoundException e)
70.         {
71.             e.printStackTrace();
72.         }
73.         return o;
74.     }
76. }

结果:
克隆前: dc1.a=100
克隆前: dc1.b=clone1
克隆前: dc1.c[0]=1000
-----------
克隆前: dc1.a=100
克隆前: dc1.b=clone1
克隆前: dc1.c[0]=1000
-----------
克隆后: dc2.a=50
克隆后: dc2.b=clone2
克隆后: dc2.c[0]=500

 

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

 

总结:当克隆的对象只有基本类型,不含引用类型时,可以用浅克隆实现.
     当克隆的对象含有引用类型时,必须使用深克隆实现.