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 try 14 { 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 }