java clone方法使用详解

Java语言的一个优势就是取消了指针的概念，但也致使了许多程序员在编程中经常忽略了对象与引用的区别，特别是先学c、c++后学java的程序员。而且因为Java不能经过简单的赋值来解决对象复制的问题，在开发过程当中，也经常要要应用clone（）方法来复制对象。好比函数参数类型是自定义的类时，此时即是引用传递而不是值传递。如下是一个小例子：

Java代码  

1. public class A {  

2.     public String name;  

3. }  

 

Java代码  

1. public class testClone {  

2.       

3.     public void changeA(A a){  

4.         a.name="b";  

5.     }  

6.     public void changInt(int i){  

7.         i=i*2+100;  

8.     }  

9.       

10.     /** 

11.      * @param args 

12.      */  

13.     public static void main(String[] args) {  

14.         // TODO Auto-generated method stub  

15.         testClone test=new testClone();  

16.         A a=new A();  

17.         a.name="a";  

18.         System.out.println("before change : a.name="+a.name);  

19.         test.changeA(a);  

20.         System.out.println("after  change : a.name="+a.name);  

21.         int i=1;  

22.         System.out.println("before change : i="+i);  

23.         test.changInt(i);  

24.         System.out.println("after  change : i="+i);  

25.     }  

26.   

27. }  

此时输出的结果是：

Java代码  

1. before change : a.name=a  

2. after  change : a.name=b  

3. before change : i=1  

4. after  change : i=1  

从这个例子知道Java对对象和基本的数据类型的处理是不同的。在Java中用对象的做为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是同样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操做。 
除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"，如：

Java代码  

1. A a1=new A();  

2. A a2=new A();  

3. a1.name="a1";  

4. a2=a1;  

5. a2.name="a2";  

6. System.out.println("a1.name="+a1.name);  

7. System.out.println("a2.name="+a2.name);  

此时输出的结果是：

Java代码  

1. a1.name=a2  

2. a2.name=a2  

若是咱们要用a2保存a1对象的数据，但又不但愿a2对象数据被改变时不影响到a1。实现clone（）方法是其一种最简单，也是最高效的手段。 
下面咱们来实现A的clone方法

Java代码  

1. public class A implements Cloneable {  

2.     public String name;  

3.   

4.     public Object clone() {  

5.         A o = null;  

6.         try {  

7.             o = (A) super.clone();  

8.         } catch (CloneNotSupportedException e) {  

9.             e.printStackTrace();  

10.         }  

11.         return o;  

12.     }  

13.   

14. }  

首先要实现Cloneable接口，而后在重载clone方法，最后在clone()方法中调用了super.clone()，这也意味着不管clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。

Java代码  

1. A a1=new A();  

2. A a2=new A();  

3. a1.name="a1";  

4. a2=a1;  (clone) ／／todo 需测试

5. a2.name="a2";  

6. System.out.println("a1.name="+a1.name);  

7. System.out.println("a2.name="+a2.name);  

此时输出的结果是：

Java代码  

1. a1.name=a1  

2. a2.name=a2  

当Class A成员变量类型是java的基本类型时（外加String类型）,只要实现如上简单的clone（称影子clone）就能够。可是若是Class A成员变量是数组或复杂类型时，就必须实现深度clone。

Java代码  

1. public class A implements Cloneable {  

2.     public String name[];  

3.       

4.     public A(){  

5.         name=new String[2];  

6.     }  

7.   

8.     public Object clone() {  

9.         A o = null;  

10.         try {  

11.             o = (A) super.clone();  

12.         } catch (CloneNotSupportedException e) {  

13.             e.printStackTrace();  

14.         }  

15.         return o;  

16.     }  

17. }  

测试代码

Java代码  

1. A a1=new A();  

2. A a2=new A();  

3. a1.name[0]="a";  

4. a1.name[1]="1";  

5. a2=(A)a1.clone();  

6. a2.name[0]="b";  

7. a2.name[1]="1";  

8. System.out.println("a1.name="+a1.name);  

9. System.out.println("a1.name="+a1.name[0]+a1.name[1]);  

10. System.out.println("a2.name="+a2.name);  

11. System.out.println("a2.name="+a2.name[0]+a2.name[1]);  

输出结果：

Java代码  

1. a1.name=[Ljava.lang.String;@757aef  

2. a1.name=b1  

3. a2.name=[Ljava.lang.String;@757aef  

4. a2.name=b1  

看到了吧，a1.name,a2.name的hash值都是@757aef,也就是说影子clone对name数组只是clone他们的地址！解决该办法是进行深度clone。

Java代码  

1. public Object clone() {  

2.         A o = null;  

3.         try {  

4.             o = (A) super.clone();  

5.             o.name=(String[])name.clone();//其实也很简单^_^  

6.         } catch (CloneNotSupportedException e) {  

7.             e.printStackTrace();  

8.         }  

9.         return o;  

10.     }  

此时输出结果是：

Java代码  

1. a1.name=[Ljava.lang.String;@757aef  

2. a1.name=a1  

3. a2.name=[Ljava.lang.String;@d9f9c3  

4. a2.name=b1  

须要注意的是Class A存在更为复杂的成员变量时，如Vector等存储对象地址的容器时，就必须clone完全。

Java代码  

1. public class A implements Cloneable {  

2.     public String name[];  

3.     public Vector<B> claB;  

4.       

5.     public A(){  

6.         name=new String[2];  

7.         claB=new Vector<B>();  

8.     }  

9.   

10.     public Object clone() {  

11.         A o = null;  

12.         try {  

13.             o = (A) super.clone();  

14.             o.name==(String[])name.clone();//深度clone  

15.             o.claB=new Vector<B>();//将clone进行到底  

16.             for(int i=0;i<claB.size();i++){  

17.                 B temp=(B)claB.get(i).clone();//固然Class B也要实现相应clone方法  

18.                 o.claB.add(temp);  

19.             }  

20.         } catch (CloneNotSupportedException e) {  

21.             e.printStackTrace();  

22.         }  

23.                 return o;  

24.     }  

25. }