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  }