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   }