（2.1.9）java的clone和浅复制克隆、深复制克隆

一、概念

java中没有指针的概念，而实质上每个new语句返回的都是一个指针的作用。

java在对基本类型，例如int,char,double都是采用值传递，即传递一个输入参数的复制，除此之外的其他类型都是引用传递，“=”复制也是这样。

但是存在这种情况：

有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。此时如果用”=“复制，传递的就是引用，会导致指向同一块对象，而不是两个独立对象。

要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。

Object类没有copy()函数

二、概念的示例

[java]  view plain copy

1. package com.zoer.src;  
2.   
3. public class ObjRef {  
4.     Obj aObj = new Obj();  
5.     int aInt = 11;  
6.   
7.     public void changeObj(Obj inObj) {  
8.         inObj.str = "changed value";  
9.     }  
10.   
11.     public void changePri(int inInt) {  
12.         inInt = 22;  
13.     }  
14.   
15.     public static void main(String[] args) {  
16.         ObjRef oRef = new ObjRef();  
17.   
18.         System.out.println("Before call changeObj() method: " + oRef.aObj);  //(1)输出 init value
19.         oRef.changeObj(oRef.aObj);  
20.         System.out.println("After call changeObj() method: " + oRef.aObj); //（2）输出 changevalue
21.   
22.         System.out.println("==================Print Primtive=================");  
23.         System.out.println("Before call changePri() method: " + oRef.aInt);  //（3）输出11
24.         oRef.changePri(oRef.aInt);  
25.         System.out.println("After call changePri() method: " + oRef.aInt);  //（4）输出11
26.   
27.     }  
28. }  

[java]  view plain copy

1. package com.zoer.src;  
2.   
3. public class Obj {  
4.   
5.     String str = "init value";  
6.   
7.     public String toString() {  
8.         return str;  
9.     }  
10. }  

这段代码的主要部分调用了两个很相近的方法，changeObj()和changePri()。唯一不同的是它们一个把对象作为输入参数，另一个把Java中的基本类型int作为输入参数。并且在这两个函数体内部都对输入的参数进行了改动。看似一样的方法，程序输出的结果却不太一样。changeObj()方法真正的把输入的参数改变了，而changePri()方法对输入的参数没有任何的改变。 

（3）输出11

（4）输出11

和C语言一样，当把Java的基本数据类型（如int，char，double等）作为入口参数传给函数体的时候，传入的参数在函数体内部变成了局部变量，这个局部变量是输入参数的一个拷贝，所有的函数体内部的操作都是针对这个拷贝的操作，函数执行结束后，这个局部变量也就完成了它的使命，它影响不到作为输入参数的变量。这种方式的参数传递被称为"值传递"。

(1)输出 init value

（2）输出 changevalue

而在Java中用对象作为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。 

 除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"。就是类似于给变量再起一个别名。两个名字都指向内存中的同一个对象。

三、使用

Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。

 在一个普通的类中，clone()方法是不可以被外部类调用的，因为在java.lang.Object类中，clone()方法是一个protected类型的方法，如果要在自己的类中提供clone()方法给外部调用，就必须重写clone()方法，并将其访问限制修改为public，这样，在外部类中才可以调用该方法。但是修改为public后，在外部调用该方法时会报一个CloneNotSupportedException的异常，原来除了重写该方法外，新的类还需要实现java.lang.Cloneable接口，这是一个空接口，不用实现任何方法。 

[java]  view plain copy

1. public class TestClone implements Cloneable{  
2.   
3.     @Override  
4.     public Object clone() throws CloneNotSupportedException {  
5.         // TODO Auto-generated method stub  
6.         return super.clone();  
7.     }  
8.       
9. }  

克隆满足的条件：

clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的有关。一般而言，clone方法满足以下条件：

1).对任何的对象x,都有：x.clone()!=x.即克隆对象与原对象不是同一个对象。

2).对任何的对象x,都有：x.clone().getClass==x.getClass(),即克隆对象与原对象的类型一样。

3).如果对象x的equals()方法定义恰当的话，x.clone().equals(x)应当是成立的。

四、影子克隆

[java]  view plain copy

1. package com.zoer.src;  
2.   
3. class UnCloneA {  
4.     private int i;  
5.   
6.     public UnCloneA(int ii) {  
7.         i = ii;  
8.     }  
9.   
10.     public void doublevalue() {  
11.         i *= 2;  
12.     }  
13.   
14.     public String toString() {  
15.         return Integer.toString(i);  
16.     }  
17. }  
18.   
19. class CloneB implements Cloneable {  
20.     public int aInt;  
21.     public UnCloneA unCA = new UnCloneA(111);  
22.   
23.     public Object clone() {  
24.         CloneB o = null;  
25.         try {  
26.             o = (CloneB) super.clone();  
27.         } catch (CloneNotSupportedException e) {  
28.             e.printStackTrace();  
29.         }  
30.         return o;  
31.     }  
32. }  
33.   
34. public class ObjRef {  
35.     public static void main(String[] a) {  
36.         CloneB b1 = new CloneB();  
37.         b1.aInt = 11;  
38.         System.out.println("before clone,b1.aInt = " + b1.aInt);  //before clone,b1.aInt = 11
39.         System.out.println("before clone,b1.unCA = " + b1.unCA);  //before clone,b1.unCA = 111
40.   
41.         CloneB b2 = (CloneB) b1.clone();  
42.         b2.aInt = 22;  
43.         b2.unCA.doublevalue();  
44.         System.out.println("=================================");  
45.         System.out.println("after clone,b1.aInt = " + b1.aInt);  //before clone,b1.aInt = 11
46.         System.out.println("after clone,b1.unCA = " + b1.unCA);  //(1)？怎么clone了还改变原值before clone,b1.unCA = 111
47.         System.out.println("=================================");  
48.         System.out.println("after clone,b2.aInt = " + b2.aInt);  //(2)因为clone了独立分体，after clone,b2.aInt = 22
49.         System.out.println("after clone,b2.unCA = " + b2.unCA);  //(3)因为clone了独立分体，clone,b2.unCA = 222
50.     }  
51. }  

       输出结果：

before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 222
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222

//before clone,b1.aInt = 11

//(2)因为clone了独立分体，after clone,b2.aInt = 22

int类型是真正的被clone了，因为改变了b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是b1.aInt的一个真正拷贝。

//(1)？怎么clone了还改变原值before clone,b1.unCA = 111

 //(3)因为clone了独立分体，clone,b2.unCA = 222

相反，对b2.unCA的改变同时改变了b1.unCA，很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。 

大多时候，这种clone的结果往往不是我们所希望的结果，这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。

五、深度克隆

  把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone(); 

[java]  view plain copy

1. package com.zoer.src;  
2.   
3. class UnCloneA implements Cloneable {  
4.     private int i;  
5.   
6.     public UnCloneA(int ii) {  
7.         i = ii;  
8.     }  
9.   
10.     public void doublevalue() {  
11.         i *= 2;  
12.     }  
13.   
14.     public String toString() {  
15.         return Integer.toString(i);  
16.     }  
17.   
18.     public Object clone() {  
19.         UnCloneA o = null;  
20.         try {  
21.             o = (UnCloneA) super.clone();  
22.         } catch (CloneNotSupportedException e) {  
23.             e.printStackTrace();  
24.         }  
25.         return o;  
26.     }  
27. }  
28.   
29. class CloneB implements Cloneable {  
30.     public int aInt;  
31.     public UnCloneA unCA = new UnCloneA(111);  
32.   
33.     public Object clone() {  
34.         CloneB o = null;  
35.         try {  
36.             o = (CloneB) super.clone();  
37.         } catch (CloneNotSupportedException e) {  
38.             e.printStackTrace();  
39.         }  
40.         o.unCA = (UnCloneA) unCA.clone();  
41.         return o;  
42.     }  
43. }  
44.   
45. public class CloneMain {  
46.     public static void main(String[] a) {  
47.         CloneB b1 = new CloneB();  
48.         b1.aInt = 11;  
49.         System.out.println("before clone,b1.aInt = " + b1.aInt);  
50.         System.out.println("before clone,b1.unCA = " + b1.unCA);  
51.   
52.         CloneB b2 = (CloneB) b1.clone();  
53.         b2.aInt = 22;  
54.         b2.unCA.doublevalue();  
55.         System.out.println("=================================");  
56.         System.out.println("after clone,b1.aInt = " + b1.aInt);  
57.         System.out.println("after clone,b1.unCA = " + b1.unCA);  
58.         System.out.println("=================================");  
59.         System.out.println("after clone,b2.aInt = " + b2.aInt);  
60.         System.out.println("after clone,b2.unCA = " + b2.unCA);  
61.     }  
62. }  

输出结果：

before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222

      可以看出，现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例，而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值，在这里，b1.i = b2.i = 11。 

        要知道不是所有的类都能实现深度clone的。例如，如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型，看一下JDK API中关于StringBuffer的说明，StringBuffer没有重载clone()方法，更为严重的是StringBuffer还是一个final类，这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和StringBuffer相似类的对象，我们有两种选择：要么只能实现影子clone，要么就在类的clone()方法中加一句（假设是SringBuffer对象，而且变量名仍是unCA）： o.unCA = new StringBuffer(unCA.toString()); //原来的是：o.unCA = (UnCloneA)unCA.clone(); 

       还要知道的是除了基本数据类型能自动实现深度clone以外，String对象是一个例外，它clone后的表现好象也实现了深度clone，虽然这只是一个假象，但却大大方便了我们的编程。 

 StrClone类中声明了CloneC类型变量c1，然后调用c1的clone()方法生成c1的拷贝c2，在对c2中的String和StringBuffer类型变量用相应的方法改动之后打印结果：

[java]  view plain copy

1. package clone;  
2.   
3. class CloneC implements Cloneable {  
4.     public String str;  
5.     public StringBuffer strBuff;  
6.   
7.     public Object clone() {  
8.         CloneC o = null;  
9.         try {  
10.             o = (CloneC) super.clone();  
11.         } catch (CloneNotSupportedException e) {  
12.             e.printStackTrace();  
13.         }  
14.         return o;  
15.     }  
16.   
17. }  
18.   
19. public class StrClone {  
20.     public static void main(String[] a) {  
21.         CloneC c1 = new CloneC();  
22.         c1.str = new String("initializeStr");  
23.         c1.strBuff = new StringBuffer("initializeStrBuff");  
24.         System.out.println("before clone,c1.str = " + c1.str);  
25.         System.out.println("before clone,c1.strBuff = " + c1.strBuff);  
26.   
27.         CloneC c2 = (CloneC) c1.clone();  
28.         c2.str = c2.str.substring(0, 5);  
29.         c2.strBuff = c2.strBuff.append(" change strBuff clone");  
30.         System.out.println("=================================");  
31.         System.out.println("after clone,c1.str = " + c1.str);  
32.         System.out.println("after clone,c1.strBuff = " + c1.strBuff);  
33.         System.out.println("=================================");  
34.         System.out.println("after clone,c2.str = " + c2.str);  
35.         System.out.println("after clone,c2.strBuff = " + c2.strBuff);  
36.     }  
37. }  
38.   
39.   
40. /* RUN RESULT 
41. before clone,c1.str = initializeStr 
42. before clone,c1.strBuff = initializeStrBuff 
43. ================================= 
44. after clone,c1.str = initializeStr 
45. after clone,c1.strBuff = initializeStrBuff change strBuff clone 
46. ================================= 
47. after clone,c2.str = initi 
48. after clone,c2.strBuff = initializeStrBuff change strBuff clone 
49. * 
50. */   

String类型的变量好象已经实现了深度clone，因为对c2.str的改动并没有影响到c1.str！难道Java把Sring类看成了基本数据类型？其实不然，这里有一个小小的把戏，秘密就在于c2.str = c2.str.substring(0,5)这一语句！实质上，在clone的时候c1.str与c2.str仍然是引用，而且都指向了同一个String对象。但在执行c2.str = c2.str.substring(0,5)的时候，它作用相当于生成了一个新的String类型，然后又赋回给c2.str。这是因为String被Sun公司的工程师写成了一个 不可更改的类（immutable class） ，在所有String类中的函数都不能更改自身的值。