影子clone,深度clone

 什么是影子clone？

下面的例子包含三个类UnCloneA，CloneB，CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量，并且重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1，然后调用clone()方法生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：

 

package clone; class UnCloneA {     private int i;     public UnCloneA(int ii) { i = ii; }     public void doubleValue() { i *= 2; }     public String toString() {         return Integer.toString(i);     } } class CloneB implements Cloneable{     public int aInt;     public UnCloneA unCA = new UnCloneA(111);     public Object clone(){         CloneB o = null;         try{             o = (CloneB)super.clone();         }catch(CloneNotSupportedException e){             e.printStackTrace();         }         return o;     } } public class CloneMain {     public static void main(String[] a){         CloneB b1 = new CloneB();         b1.aInt = 11;         System.out.println("before clone,b1.aInt = "+ b1.aInt);         System.out.println("before clone,b1.unCA = "+ b1.unCA);                         CloneB b2 = (CloneB)b1.clone();         b2.aInt = 22;         b2.unCA.doubleValue();         System.out.println("=================================");         System.out.println("after clone,b1.aInt = "+ b1.aInt);         System.out.println("after clone,b1.unCA = "+ b1.unCA);         System.out.println("=================================");         System.out.println("after clone,b2.aInt = "+ b2.aInt);         System.out.println("after clone,b2.unCA = "+ b2.unCA);     } } /** RUN RESULT: 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 */

 

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

 

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

 

l     怎么进行深度clone？

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

程序如下：

package clone.ext; class UnCloneA implements Cloneable{     private int i;     public UnCloneA(int ii) { i = ii; }     public void doubleValue() { i *= 2; }     public String toString() {         return Integer.toString(i);     }     public Object clone(){         UnCloneA o = null;         try{             o = (UnCloneA)super.clone();         }catch(CloneNotSupportedException e){             e.printStackTrace();         }         return o;     } } class CloneB implements Cloneable{     public int aInt;     public UnCloneA unCA = new UnCloneA(111);     public Object clone(){         CloneB o = null;         try{             o = (CloneB)super.clone();         }catch(CloneNotSupportedException e){             e.printStackTrace();         }         o.unCA = (UnCloneA)unCA.clone();         return o;     } } public class CloneMain {     public static void main(String[] a){         CloneB b1 = new CloneB();         b1.aInt = 11;         System.out.println("before clone,b1.aInt = "+ b1.aInt);         System.out.println("before clone,b1.unCA = "+ b1.unCA);                         CloneB b2 = (CloneB)b1.clone();         b2.aInt = 22;         b2.unCA.doubleValue();         System.out.println("=================================");         System.out.println("after clone,b1.aInt = "+ b1.aInt);         System.out.println("after clone,b1.unCA = "+ b1.unCA);         System.out.println("=================================");         System.out.println("after clone,b2.aInt = "+ b2.aInt);         System.out.println("after clone,b2.unCA = "+ b2.unCA);     } } /** RUN RESULT: 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，虽然这只是一个假象，但却大大方便了我们的编程。

 

l     Clone中String和StringBuffer的区别

应该说明的是，这里不是着重说明String和StringBuffer的区别，但从这个例子里也能看出String类的一些与众不同的地方。

 

下面的例子中包括两个类，CloneC类包含一个String类型变量和一个StringBuffer类型变量，并且实现了clone()方法。在StrClone类中声明了CloneC类型变量c1，然后调用c1的clone()方法生成c1的拷贝c2，在对c2中的String和StringBuffer类型变量用相应的方法改动之后打印结果：

package clone; class CloneC implements Cloneable{     public String str;     public StringBuffer strBuff;     public Object clone(){         CloneC o = null;         try{             o = (CloneC)super.clone();         }catch(CloneNotSupportedException e){             e.printStackTrace();         }         return o;     }     } public class StrClone {     public static void main(String[] a){         CloneC c1 = new CloneC();         c1.str = new String("initializeStr");         c1.strBuff = new StringBuffer("initializeStrBuff");         System.out.println("before clone,c1.str = "+ c1.str);         System.out.println("before clone,c1.strBuff = "+ c1.strBuff);                         CloneC c2 = (CloneC)c1.clone();         c2.str = c2.str.substring(0,5);         c2.strBuff = c2.strBuff.append(" change strBuff clone");         System.out.println("=================================");         System.out.println("after clone,c1.str = "+ c1.str);         System.out.println("after clone,c1.strBuff = "+ c1.strBuff);         System.out.println("=================================");         System.out.println("after clone,c2.str = "+ c2.str);         System.out.println("after clone,c2.strBuff = "+ c2.strBuff);     } } /* RUN RESULT before clone,c1.str = initializeStr before clone,c1.strBuff = initializeStrBuff ================================= after clone,c1.str = initializeStr after clone,c1.strBuff = initializeStrBuff change strBuff clone ================================= after clone,c2.str = initi after clone,c2.strBuff = initializeStrBuff change strBuff clone * */

 

打印的结果可以看出，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类中的函数都不能更改自身的值。下面给出很简单的一个例子：

 

package clone;

public class StrTest { public static void main(String[] args) {

String str1 = "This is a test for immutable";

String str2 = str1.substring(0,8);

System.out.println("print str1 : " + str1);

System.out.println("print str2 : " + str2); }

 } /* RUN RESULT print str1 : This is a test for immutable print str2 : This is */

 

例子中，虽然str1调用了substring()方法，但str1的值并没有改变。类似的，String类中的其它方法也是如此。当然如果我们把最上面的例子中的这两条语句

 

c2.str = c2.str.substring(0,5); c2.strBuff = c2.strBuff.append(" change strBuff clone");

 

改成下面这样：

c2.str.substring(0,5); c2.strBuff.append(" change strBuff clone");

 

去掉了重新赋值的过程，c2.str也就不能有变化了，我们的把戏也就露馅了。但在编程过程中只调用

c2.str.substring(0,5);

 

语句是没有任何意义的。

应该知道的是在Java中所有的基本数据类型都有一个相对应的类，象Integer类对应int类型，Double类对应double类型等等，这些类也与String类相同，都是不可以改变的类。也就是说，这些的类中的所有方法都是不能改变其自身的值的。这也让我们在编clone类的时候有了一个更多的选择。同时我们也可以把自己的类编成不可更改的类。