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=aafter change : a.name=bbefore change : i=1after 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=a2a2.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=a1a2.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;@757aefa1.name=b1a2.name=[Ljava.lang.String;@757aefa2.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;@757aefa1.name=a1a2.name=[Ljava.lang.String;@d9f9c3a2.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 （转）