java clone方法使用详解（转）

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

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

此时输出的结果是：
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 { 3     public String name; 4  5     public Object clone() 6     { 7         A o = null; 8         try 9         {10             o = (A) super.clone();11         } catch (CloneNotSupportedException e)12         {13             e.printStackTrace();14         }15         return o;16     }17 }

首先要实现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 = (A)a1.clone();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 { 3     public String name[]; 4  5     public A() 6     { 7         name = new String[2]; 8     } 9 10     public Object clone()11     {12         A o = null;13         try14         {15             o = (A) super.clone();16         } catch (CloneNotSupportedException e)17         {18             e.printStackTrace();19         }20         return o;21     }22 }

测试代码

 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     { 3         A o = null; 4         try 5         { 6             o = (A) super.clone(); 7         } catch (CloneNotSupportedException e) 8         { 9             e.printStackTrace();10         }11         o.name = new String[2];// 其实也很简单^_^12         return o;13     }

此时输出结果是：
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  }

（转）http://blog.csdn.net/ilibaba/article/details/3773545