java clone方法使用詳解

Java語言的一個優點就是取消了指標的概念，但也導致了許多程式員在編程中常常忽略了對象與引用的區別，特別是先學c、c++後學java的程式員。並且由於Java不能通過簡單的賦值來解決對象複製的問題，在開發過程中，也常常要要應用clone（）方法來複製對象。比如函數參數類型是自訂的類時，此時便是引用傳遞而不是值傳遞。以下是一個小例子：

1. public class A {   
2.    public String name;   
3. }

1. public class testClone {           
2.     public void changeA(A a){   
3.          a.name="b";   
4.      }   
5.      public void changInt(int i){   
6.          i=i*2+100;   
7.      }   
8.         
9.      /**  
10.       * @param args  
11.       */  
12.      public static void main(String[] args) {   
13.          // TODO Auto-generated method stub   
14.          testClone test=new testClone();   
15.          A a=new A();   
16.          a.name="a";   
17.          System.out.println("before change : a.name="+a.name);   
18.          test.changeA(a);   
19.          System.out.println("after  change : a.name="+a.name);   
20.          int i=1;   
21.          System.out.println("before change : i="+i);   
22.          test.changInt(i);   
23.          System.out.println("after  change : i="+i);   
24.     }   
25.    
26.  }

此時輸出的結果是：
before change : a.name=a
after  change : a.name=b
before change : i=1
after  change : i=1

從這個例子知道Java對對象和基本的資料類型的處理是不一樣的。在Java中用對象的作為入口參數的傳遞則預設為"引用傳遞"，也就是說僅僅傳遞了對象的一個"引用"，這個"引用"的概念同C語言中的指標引用是一樣的。當函數體內部對輸入變數改變時，實質上就是在對這個對象的直接操作。
除了在函數傳值的時候是"引用傳遞"，在任何用"＝"向物件變數賦值的時候都是"引用傳遞"，如：

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)

此時輸出的結果是：
a1.name=a2
a2.name=a2

如果我們要用a2儲存a1對象的資料，但又不希望a2對象資料被改變時不影響到a1。實現clone（）方法是其一種最簡單，也是最高效的手段。
下面我們來實現A的clone方法

1. public class A implements Cloneable {
2.  public String name;
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. }

首先要實現Cloneable介面，然後在重載clone方法，最後在clone()方法中調用了super.clone()，這也意味著無論clone類的繼承結構是什麼樣的，super.clone()直接或間接調用了java.lang.Object類的clone()方法。

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);

此時輸出的結果是：
a1.name=a1
a2.name=a2

當Class A成員變數類型是java的基本類型時（外加String類型）,只要實現如上簡單的clone（稱影子clone）就可以。但是如果Class A成員變數是數組或複雜類型時，就必須實現深度clone。

1. public class A implements Cloneable {
2.  public String name[];
3.  
4.  public A(){
5.   name=new String[2];
6.  }
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. }

測試代碼

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]);

輸出結果：
a1.name=[Ljava.lang.String;@757aef
a1.name=b1
a2.name=[Ljava.lang.String;@757aef
a2.name=b1

看到了吧，a1.name,a2.name的hash值都是@757aef,也就是說影子clone對name數組只是clone他們的地址！解決該辦法是進行深度clone。

1. public Object clone() {
2.   A o = null;
3.   try {
4.    o = (A) super.clone();
5.   } catch (CloneNotSupportedException e) {
6.    e.printStackTrace();
7.   }
8.   o.name=new String[2];//其實也很簡單^_^
9.   return o;
10.  }

此時輸出結果是：
a1.name=[Ljava.lang.String;@757aef
a1.name=a1
a2.name=[Ljava.lang.String;@d9f9c3
a2.name=b1

需要注意的是Class A存在更為複雜的成員變數時，如Vector等儲存物件地址的容器時，就必須clone徹底。

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.          } catch (CloneNotSupportedException e) {   
15.              e.printStackTrace();   
16.          }   
17.          o.name=new String[2];//深度clone   
18.          o.claB=new Vector<B>();//將clone進行到底   
19.          for(int i=0;i<claB.size();i++){   
20.              B temp=(B)claB.get(i).clone();//當然Class B也要實現相應clone方法
21.              o.claB.add(temp);   
22.          }   
23.          return o;   
24.      }   
25.  }