java 中的 clone()

首先要明确一点，如果目标类没有实现自己的clone()方法，该类的实例instance.clone()实际调用的是Object.clone()。

1） 无论目标类是否实现了Cloneable接口，只要调用到了Object.clone()，比如通过super.clone()，那么就必须处理或者抛出CloneNotSupportedException，因为Object.clone()有throws这个异常，有抛的就必然有接的。

2) Object.clone()按照如下步骤执行：
  (1) 检查执行此方法的当前类有没有应用Clonable接口，如果没有，抛出CloneNotSupportedException异常。
  (2) 如果当前类有应用Clonable接口，则为当前类创建一个新对象，并将原对象中的所有字段进行一次浅层拷贝（通过赋值进行）。所以如果一个目标类应用了Clonable接口但并未重写clone()方法，它“看起来”仍然可以克隆。为什么是“看起来”下面会解释。

3） 为什么应用了Cloneable接口的类通常还必须重写一个public的clone()方法？这里有两个原因：
  (1) 如果不重写，由于Object.clone()是proteced属性，所以这个clone()方法将无法在外部被调用，更精确地说，无法在目标类之外的任何地方调用。这样就使得克隆失去了用武之地。

  (2) Object.clone()毕竟只是提供了浅层拷贝，对于基本类型的字段，可以说它成功克隆了。但对于对象型字段，它并没有实现克隆的功能，仅仅做了一个赋值。试运行一下下面的代码就会更清楚了：

[java] view plaincopyprint?public class Student implements Cloneable  
{ 
    private int id; 
    private String name; 
    public StringBuffer sb = new StringBuffer(""); 
 
    public Student() { 
        this.id = 744; 
        this.name = "FL"; 
    } 
 
    public Student(int id, String name) { 
        this.id = id; 
        this.name = name; 
    } 
 
    public boolean equals(Object obj) { 
        return this.id == ((Student) obj).id; 
    } 
 
    public String toString() { 
        return "Student id : " + id + " Name " + name; 
    }     
 
    public static void main(String[] args) throws CloneNotSupportedException // 这里为什么一定得写  
    { 
        Student s1 = new Student(101, "WangQiang"); 
        Student s2 = (Student) s1.clone(); 
        System.out.println(s1 == s2); 
        System.out.println(s1); 
        System.out.println(s2); 
 
        s1.sb.append("s1's string"); 
        System.out.println("s2.sb's value = " + s2.sb.toString()); 
        System.out.println(s1.sb==s2.sb); 
         
    } 
} 

public class Student implements Cloneable
{
    private int id;
    private String name;
    public StringBuffer sb = new StringBuffer("");

    public Student() {
        this.id = 744;
        this.name = "FL";
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public boolean equals(Object obj) {
        return this.id == ((Student) obj).id;
    }

    public String toString() {
        return "Student id : " + id + " Name " + name;
    }   

    public static void main(String[] args) throws CloneNotSupportedException // 这里为什么一定得写
    {
        Student s1 = new Student(101, "WangQiang");
        Student s2 = (Student) s1.clone();
        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);

        s1.sb.append("s1's string");
        System.out.println("s2.sb's value = " + s2.sb.toString());
        System.out.println(s1.sb==s2.sb);
       
    }
}
以上例子运行显示，不重写Object.clone()方法的话在目标类内部仍然可以调用目标类.clone()，但浅层拷贝导致s1和s2共享同一个StringBuffer对象，这是很危险的。

 

4) 运行时是否抛出CloneNotSupportedException跟是否重写了clone()方法没有关系，只跟是否应用了Cloneable接口有关系。

5） 重写clone()方法不一定需要应用Cloneable接口，因为只有执行Object.clone()方法才会做这个检查。但如果重写的clone()方法中调用了super.clone()，那就必须应用Cloneable接口，原因不难理解。

6）应用Cloneable接口的好处在于，它可以允许你安全地调用super.clone()，从而快速地产生一个浅拷贝，之后只需要在重写的公共clone()方法中修改必须修改的字段，如那些不允许共享实例的对象。