java clone方法使用详解 - ilibaba的专栏 - CSDNBlog

来源:百度文库 编辑:神马文学网 时间:2022/12/09 13:20:22
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;

  3.  public Object clone() {
  4.   A o = null;
  5.   try {
  6.    o = (A) super.clone();
  7.   } catch (CloneNotSupportedException e) {
  8.    e.printStackTrace();
  9.   }
  10.   return o;
  11.  }
  12. }
首先要实现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.  }

  7.  public Object clone() {
  8.   A o = null;
  9.   try {
  10.    o = (A) super.clone();
  11.   } catch (CloneNotSupportedException e) {
  12.    e.printStackTrace();
  13.   }
  14.   return o;
  15.  }
  16. }
测试代码
  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 claB;   
  4.         
  5.      public A(){   
  6.          name=new String[2];   
  7.          claB=new Vector();   
  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();//将clone进行到底   
  19.          for(int i=0;i             B temp=(B)claB.get(i).clone();//当然Class B也要实现相应clone方法
  20.              o.claB.add(temp);   
  21.          }   
  22.          return o;   
  23.      }   
  24.  }