Java clone()方法使用說明，javaclone

Java clone()方法使用說明，javaclone

        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;  
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. }