Java語言的一個優點就是取消了指針的概念,但也導致了許多程序員在編程中常常忽略了對象與引用(此引用非C++中的引用)的區別,特別是先學c、c++后學java的程序員。并且由于Java不能通過簡單的賦值來解決對象復制的問題,在開發過程中,也常常要要應用clone()方法來復制對象。比如函數參數類型是自定義的類時,此時便是引用傳遞而不是值傳遞。以下是一個小例子:
- public class A {
- public String name;
- }
- public class testClone {
- public void changeA(A a){
- a.name="b";
- }
- public void changInt(int i){
- i=i*2+100;
- }
- /**
- * @param args
- */
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- testClone test=new testClone();
- A a=new A();
- a.name="a";
- System.out.println("before change : a.name="+a.name);
- test.changeA(a);
- System.out.println("after change : a.name="+a.name);
- int i=1;
- System.out.println("before change : i="+i);
- test.changInt(i);
- System.out.println("after change : i="+i);
- }
- }
此時輸出的結果是:
- before change : a.name=a
- after change : a.name=b
- before change : i=1
- after change : i=1
從這個例子知道Java對對象和基本的數據類型的處理是不一樣的。在Java中用對象的作為入口參數的傳遞則缺省為"引用傳遞",也就是說僅僅傳遞了對象的一個"引用",這個"引用"的概念同C語言中的指針引用是一樣的。當函數體內部對輸入變量改變時,實質上就是在對這個對象的直接操作。
除了在函數傳值的時候是"引用傳遞",在任何用"="向對象變量賦值的時候都是"引用傳遞",如:
- A a1=new A();
- A a2=new A();
- a1.name="a1";
- a2=a1;
- a2.name="a2";
- System.out.println("a1.name="+a1.name);
- System.out.println("a2.name="+a2.name);
此時輸出的結果是:
- a1.name=a2
- a2.name=a2
如果我們要用a2保存a1對象的數據,但又不希望a2對象數據被改變時不影響到a1。實現clone()方法是其一種最簡單,也是最高效的手段。
下面我們來實現A的clone方法
- public class A implements Cloneable {
- public String name;
- public Object clone() {
- A o = null;
- try {
- o = (A) super.clone();
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return o;
- }
- }
首先要實現Cloneable接口,然后在重載clone方法,最后在clone()方法中調用了super.clone(),這也意味著無論clone類的繼承結構是什么樣的,super.clone()直接或間接調用了java.lang.Object類的clone()方法。
- A a1=new A();
- A a2=new A();
- a1.name="a1";
- a2=a1;
- a2.name="a2";
- System.out.println("a1.name="+a1.name);
- System.out.println("a2.name="+a2.name);
此時輸出的結果是:
- a1.name=a1
- a2.name=a2
當Class A成員變量類型是java的基本類型時(外加String類型),只要實現如上簡單的clone(稱影子clone)就可以。但是如果Class A成員變量是數組或復雜類型時,就必須實現深度clone。
- public class A implements Cloneable {
- public String name[];
- public A(){
- name=new String[2];
- }
- public Object clone() {
- A o = null;
- try {
- o = (A) super.clone();
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return o;
- }
- }
測試代碼
- A a1=new A();
- A a2=new A();
- a1.name[0]="a";
- a1.name[1]="1";
- a2=(A)a1.clone();
- a2.name[0]="b";
- a2.name[1]="1";
- System.out.println("a1.name="+a1.name);
- System.out.println("a1.name="+a1.name[0]+a1.name[1]);
- System.out.println("a2.name="+a2.name);
- 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。
- public Object clone() {
- A o = null;
- try {
- o = (A) super.clone();
- o.name=(String[])name.clone();//其實也很簡單^_^
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return o;
- }
此時輸出結果是:
- a1.name=[Ljava.lang.String;@757aef
- a1.name=a1
- a2.name=[Ljava.lang.String;@d9f9c3
- a2.name=b1
需要注意的是Class A存在更為復雜的成員變量時,如Vector等存儲對象地址的容器時,就必須clone徹底。
- public class A implements Cloneable {
- public String name[];
- public Vector<B> claB;
- public A(){
- name=new String[2];
- claB=new Vector<B>();
- }
- public Object clone() {
- A o = null;
- try {
- o = (A) super.clone();
- o.name==(String[])name.clone();//深度clone
- o.claB=new Vector<B>();//將clone進行到底
- for(int i=0;i<claB.size();i++){
- B temp=(B)claB.get(i).clone();//當然Class B也要實現相應clone方法
- o.claB.add(temp);
- }
- } catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return o;
- }
- }