Java的clone方法

什么是"clone"？ 

　　在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能 会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在 Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。 

　 　Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用 new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。 

　　怎样应用clone()方法？ 

　　一个很典型的调用clone()代码如下： 

class CloneClass implements Cloneable{  　public int aInt;  　public Object clone(){  　　CloneClass o = null;  　　try{  　　　o = (CloneClass)super.clone();  　　}catch(CloneNotSupportedException e){  　　　e.printStackTrace();  　　}  　　return o;  　}  ｝

　 　有三个值得注意的地方，一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang 包，java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方 法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或 间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。 

　　应该说第三点是最重要的，仔细 观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非native方法。这也解释了为 什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了clone功能。对于第二点，也要 观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在 Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone 类的clone()方法，重载之后要把clone()方法的属性设置为public。 

　　那么clone类为什么还要实现 Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对 Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了 super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。 

　　以上是clone的最基本的步骤，想要完成一个成功的clone，还要了解什么是"影子clone"和"深度clone"。

一步一个脚印，方便自己复习，该出手时就出手，有错误，一定要指正，非常感谢，共同进步！

//测试类  public class Exec {       public static void main(String args[]) {           // 新建图书集合类变量，修改部分图书信息           BookCollection bc1 = new BookCollection( 10 );           bc1.getBooks()[ 0 ].setBookID( 100 );           bc1.getBooks()[ 1 ].setISBN( "9601000980" );               // 使用clone方法实现类变量复制           BookCollection bc2 = (BookCollection) bc1.clone();           System.out.println(bc2.getBooks()[ 0 ].getBookID());           System.out.println(bc2.getBooks()[ 1 ].getISBN());       }  }      // 支持类变量复制的图书集合类  class BookCollection implements Cloneable {       // 存储所有图书类变量的数组       private Book[] books = null ;       // 图书总数       private int number;           // 默认构造函数       public BookCollection() {       }           // 该构造函数按照指定数量初始化图书类变量数组       public BookCollection( int number) {           this .number = number;           books = new Book[number];                       // 每个图书类变量的ID都是一个从1开始连续分配的整数           for ( int i = 0 ; i < books.length; i++) {               books[i] = new Book(i + 1 );           }       }           // 支持类变量复制的重要方法       public Object clone() {           // 新建图书集合类变量           BookCollection result = new BookCollection();                   // 将新建类变量的所有图书信息设置与当前图书信息相同           result.books = new Book[number];           for ( int i = 0 ; i < number; i++) {               result.books[i] = (Book) books[i].clone();           }           return result;       }           // 图书数组的读取函数       public Book[] getBooks() {           return books;       }      }      // 图书类  class Book implements Cloneable {       // 图书ID号       private int bookID;               // 图书的ISBN号       private String ISBN;               // 图书的标题       private String title;           // 默认构造函数       public Book() {       }           // 该构造函数只对图书ID进行初始化       public Book( int bookID) {           setBookID(bookID);       }           // 该构造函数对图书ID号，ISBN号和标题进行初始化       public Book( int bookID, String ISBN, String title) {           setBookID(bookID);           setISBN(ISBN);           setTitle(title);       }           // 图书ID的读取函数       public int getBookID() {           return bookID;       }           // 图书ID的设置函数       public void setBookID( int bookID) {           this .bookID = bookID;       }           // ISDN号的读取函数       public String getISBN() {           return ISBN;       }           // ISDN号的设置函数       public void setISBN(String ISBN) {           this .ISBN = ISBN;       }           // 图书标题的读取函数       public String getTitle() {           return title;       }           // 图书标题的设置函数       public void setTitle(String title) {           this .title = title;       }           // 支持类变量复制的重要方法       public Object clone() {           Object obj = null ;           try {               // 直接调用Object类提供的clone方法复制当前类变量               // 如果当前类变量有其他类变量的引用属性，则不应该使用此方法，而应写为               // obj = new Book();               // ((Book)obj).setBookID(bookID);               // ((Book)obj).setISBN(ISBN);               // ((Book)obj).setTitle(title);               obj = super .clone();           } catch (Exception e) {               System.out.println(e.getMessage());           }           return obj;       }  }

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

Java代码  

1. public class A {  
2.     public String name;  
3. }  

 

Java代码  

1. public class testClone {  
2.       
3.     public void changeA(A a){  
4.         a.name="b";  
5.     }  
6.     public void changInt(int i){  
7.         i=i*2+100;  
8.     }  
9.       
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         // TODO Auto-generated method stub  
15.         testClone test=new testClone();  
16.         A a=new A();  
17.         a.name="a";  
18.         System.out.println("before change : a.name="+a.name);  
19.         test.changeA(a);  
20.         System.out.println("after  change : a.name="+a.name);  
21.         int i=1;  
22.         System.out.println("before change : i="+i);  
23.         test.changInt(i);  
24.         System.out.println("after  change : i="+i);  
25.     }  
26.   
27. }  

此时输出的结果是：

Java代码  

1. before change : a.name=a  
2. after  change : a.name=b  
3. before change : i=1  
4. after  change : i=1  

从这个例子知道Java对对象和基本的数据类型的处理是不一样的。在Java中用对象的作为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。 
除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"，如：

Java代码  

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);  

此时输出的结果是：

Java代码  

1. a1.name=a2  
2. a2.name=a2  

如果我们要用a2保存a1对象的数据，但又不希望a2对象数据被改变时不影响到a1。实现clone（）方法是其一种最简单，也是最高效的手段。 
下面我们来实现A的clone方法

Java代码  

1. public class A implements Cloneable {  
2.     public String name;  
3.   
4.     public Object clone() {  
5.         A o = null;  
6.         try {  
7.             o = (A) super.clone();  
8.         } catch (CloneNotSupportedException e) {  
9.             e.printStackTrace();  
10.         }  
11.         return o;  
12.     }  
13.   
14. }  

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

Java代码  

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);  

此时输出的结果是：

Java代码  

1. a1.name=a1  
2. a2.name=a2  

当Class A成员变量类型是java的基本类型时（外加String类型）,只要实现如上简单的clone（称影子clone）就可以。但是如果Class A成员变量是数组或复杂类型时，就必须实现深度clone。

Java代码  

1. public class A implements Cloneable {  
2.     public String name[];  
3.       
4.     public A(){  
5.         name=new String[2];  
6.     }  
7.   
8.     public Object clone() {  
9.         A o = null;  
10.         try {  
11.             o = (A) super.clone();  
12.         } catch (CloneNotSupportedException e) {  
13.             e.printStackTrace();  
14.         }  
15.         return o;  
16.     }  
17. }  

测试代码

Java代码  

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]);  

输出结果：

Java代码  

1. a1.name=[Ljava.lang.String;@757aef  
2. a1.name=b1  
3. a2.name=[Ljava.lang.String;@757aef  
4. a2.name=b1  

看到了吧，a1.name,a2.name的hash值都是@757aef,也就是说影子clone对name数组只是clone他们的地址！解决该办法是进行深度clone。

Java代码  

1. public Object clone() {  
2.         A o = null;  
3.         try {  
4.             o = (A) super.clone();  
5.             o.name=(String[])name.clone();//其实也很简单^_^  
6.         } catch (CloneNotSupportedException e) {  
7.             e.printStackTrace();  
8.         }  
9.         return o;  
10.     }  

此时输出结果是：

Java代码  

1. a1.name=[Ljava.lang.String;@757aef  
2. a1.name=a1  
3. a2.name=[Ljava.lang.String;@d9f9c3  
4. a2.name=b1  

需要注意的是Class A存在更为复杂的成员变量时，如Vector等存储对象地址的容器时，就必须clone彻底。

Java代码  

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.             o.name==(String[])name.clone();//深度clone  
15.             o.claB=new Vector<B>();//将clone进行到底  
16.             for(int i=0;i<claB.size();i++){  
17.                 B temp=(B)claB.get(i).clone();//当然Class B也要实现相应clone方法  
18.                 o.claB.add(temp);  
19.             }  
20.         } catch (CloneNotSupportedException e) {  
21.             e.printStackTrace();  
22.         }  
23.                 return o;  
24.     }  
25. }