Java Object Cloning

1. Overiew 
  在实际编程中，我们经常会遇到这样一个情景：有一个对象A，存在属性方法，现在需要一个和A完全相同的新对象B，并且B的任何改动都不会影响到A中的值。那么，最常用的办法就是对A进行克隆。 

2. How to Clone 
  在java.lang.Object中有一个clone方法，该方法的签名如下： 

Java代码   

1. protected native Object clone() throws CloneNotSupportedException;  

  该方法返回一个Object实例的拷贝，该实例拷贝具有： 
    1)拷贝对象是一个新对象而不是一个原对象引用。 
    2)拷贝的对象中包含的是原有对象信息，而不是对象初始化的信息(也就是说，拷贝过程没有调用构造函数)。 

  从第1条我们可以看出，拷贝的对象与原对象存在这样一种关系： 

Java代码   

1. 1. x.clone() != x      will be true  
2. 2. x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements     
3. 3. x.clone().equals(x) will be true, but these are not absolute requirements  

  要实现克隆，必须满足一下三点： 
     1)类必须实现Cloneable接口 
     2)类必须重载Object类中的clone()方法 
     3)重载的clone()方法中，必须显示调用super.clone()。 

  我们看一下Cloneable接口的定义: 

Java代码   

1. public interface Cloneable { }  

  Cloneable接口是不包含任何方法的,仅仅表示一个标志(类似Serializable接口)，而且这个标志也是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。 

  按照要求，我们写一个克隆类的小例子: 

Java代码   

1. public class DummyClone implements Cloneable{  
2.   
3.     public Object clone(){  
4.         DummyClone dc = null;  
5.         try {  
6.             dc = (DummyClone)super.clone();  
7.         } catch (CloneNotSupportedException e) {  
8.             e.printStackTrace();  
9.         }  
10.         return dc;  
11.     }  
12. }  

3. Shadow Clone 
  首先，我们来看一个例子：ClassA没有实现Cloneable接口。ClassB存在ClassA的实例，实现了Cloneable接口，并重载了clone方法。ClassC实例化一个ClassB对象，然后克隆一个对象。 

Java代码   

1. class ClassA {  
2.       
3.     public int a;  
4.       
5.     public void doubleA(){  
6.         a = a * 2;  
7.     }  
8.       
9.     public ClassA(int aa){  
10.         this.a = aa;  
11.     }  
12.       
13.     public String toString(){  
14.         return Integer.toString(a);  
15.     }  
16. }  
17.   
18. class ClassB implements Cloneable{  
19.       
20.     public int b;  
21.       
22.     public ClassA ca = new ClassA(11);  
23.       
24.     public Object clone(){  
25.         ClassB cb = null;  
26.         try {  
27.             cb = (ClassB)super.clone();  
28.         } catch (CloneNotSupportedException e) {  
29.             e.printStackTrace();  
30.         }  
31.         return cb;  
32.     }  
33. }  
34.   
35. public class ClassC {  
36.       
37.     public static void main(String[] args) {  
38.         ClassB cb = new ClassB();  
39.         cb.b = 222;  
40.         System.out.println("before clone : cb.b = " + cb.b);  
41.         System.out.println("before clone : cb.ca = " + cb.ca);  
42.           
43.         //  
44.         ClassB cb2 = (ClassB)cb.clone();  
45.         cb2.b = 3333;  
46.         cb2.ca.doubleA();  
47.         System.out.println("========================");  
48.         System.out.println("after clone : cb.b = " + cb.b);  
49.         System.out.println("after clone : cb.ca = " + cb.ca);  
50.         System.out.println("========================");  
51.         System.out.println("after clone : cb2.b = " + cb2.b);  
52.         System.out.println("after clone : cb2.ca = " + cb2.ca);  
53.     }  
54. }  

  输出结果如下： 

Java代码   

1. before clone : cb.b = 222  
2. before clone : cb.ca = 11  
3. ========================  
4. after clone : cb.b = 222  
5. after clone : cb.ca = 22  
6. ========================  
7. after clone : cb2.b = 3333  
8. after clone : cb2.ca = 22  

  从结果我们看到，int类型的b被完全的克隆了，而ClassA类型的ca却没有被克隆。因为克隆后cb2对b的赋值不会影响原有cb中b的值，而调用cb2.ca.doubleA()方法后，对cb2.ca的改变同时改变了cb.ca，表明cb2.ca与cb.ca仅仅指向同一个对象的不同引用。从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量clone后的变量和原始对象中相应的变量指向的是同一个对象。 

  这就是影子克隆。影子克隆，并没有完整的完成克隆，有时候这并不是我们想要的结果。我们有时需要，就像列子中调用cb2.ca.doubleA()方法时，不会对原对象产生改变，这时候我们就需要deep clone; 

4. Deep Clone 
  要实现深度克隆,在上面的例子基础上，我们只需要这样修改即可： 

Java代码   

1. class ClassA implements Cloneable{  
2.       
3.     public int a;  
4.       
5.     public void doubleA(){  
6.         a = a * 2;  
7.     }  
8.       
9.     public ClassA(int aa){  
10.         this.a = aa;  
11.     }  
12.       
13.     public String toString(){  
14.         return Integer.toString(a);  
15.     }  
16.       
17.     public Object clone(){  
18.         ClassA ca = null;  
19.         try {  
20.             ca = (ClassA)super.clone();  
21.         } catch (CloneNotSupportedException e) {  
22.             e.printStackTrace();  
23.         }  
24.         return ca;  
25.     }  
26. }  
27.   
28. class ClassB implements Cloneable{  
29.       
30.     public int b;  
31.       
32.     public ClassA ca = new ClassA(11);  
33.       
34.     public Object clone(){  
35.         ClassB cb = null;