世界热点评！java编程中的对象与引用的区别 java clone方法使用详解

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

1 public classA {2 publicString name;3 }4 public classtestClone {5 public voidchangeA(A a){6 a.name="b";7 }8 public void changInt(inti){9 i=i*2+100;10 }11

(相关资料图)

12 /**

13 *@paramargs14 */

15 public static voidmain(String[] args) {16 //TODO Auto-generated method stub

17 testClone test=newtestClone();18 A a=newA();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=newA();2 A a2=newA();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 implementsCloneable2 {3 publicString name;4

5 publicObject clone()6 {7 A o = null;8 try

9 {10 o = (A) super.clone();11 } catch(CloneNotSupportedException e)12 {13 e.printStackTrace();14 }15 returno;16 }17 }

首先要实现Cloneable接口，然后在重载clone方法，最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。

1 A a1 = newA();2 A a2 = newA();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 implementsCloneable2 {3 publicString name[];4

5 publicA()6 {7 name = new String[2];8 }9

10 publicObject clone()11 {12 A o = null;13 try

14 {15 o = (A) super.clone();16 } catch(CloneNotSupportedException e)17 {18 e.printStackTrace();19 }20 returno;21 }22 }

测试代码

1 A a1=newA();2 A a2=newA();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 publicObject 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 returno;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 implementsCloneable {2 publicString name[];3 public VectorclaB;4

5 publicA(){6 name=new String[2];7 claB=new Vector();8 }9

10 publicObject 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

21 o.claB.add(temp);22 }23 returno;24 }25 }