Java 的 clone 方法 && 淺復制和深復制

1 Java中對象的創建過程

java創建對象的方式有以下兩種：

（1）使用new操作符創建一個對象

（2）使用clone的方法復制一個對象，（在Java中，clone是Object類的protected方法）

這兩種對象創建方法有什么區別？

• new操作時，首先根據new后面的類型（知道類型才能判斷需要分配多大的內存空間）分配內存空間（此時分配到的內存空間相當於產生了一個新的對象，只是還有初始化），分配完內存空間后，在調用構造函數，初始化對象（填充對象的各個域的值）。構造方法返回后，一個對象創建完畢，可以把它的引用發布到外面，可以根據這個引用操作這個對象。
• clone方法拷貝對象的第一步與new操作類似，都是分配內存，調用clone方法時，分配的內存和源對象（即調用的clone方法的對象）相同，然后再使用源對象中對應的各個域，填充新對象域，填充完成后，clone方法返回，一個新的相同的對象被創建，同樣可以把這個新對象的引用發布到外部。

2 復制對象 && 復制引用

首先定義一個Person類

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

測試：

public static void main(String[] args) {
        Person p = new Person(23, "zhang");  
        Person p1 = p;  
          
        System.out.println(p);  
        System.out.println(p1);         
    }

運行結果：

test1.Person@5f4fcc96
test1.Person@5f4fcc96

由此可知p和p1指向的是同一個對象，p和p1只是引用而已。它們都指向了一個相同的對象Person(23, "zhang") 。 可以把這種現象叫做引用的復制。

 

 

 

 

 

 

下面代碼表示克隆了一個對象：

public class Person implements Cloneable{
    private String name;
    private int age;

    public Person(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException { return super.clone(); }
    
    

}

    public static void main(String[] args) {
        Person p = new Person(23, "zhang");  
        Person p1 = null;
        try {
            p1 = (Person) p.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        } 
          
        System.out.println(p);  
        System.out.println(p1); 
          
    }

運行結果：

test1.Person@2f57d162
test1.Person@2e739136

由結果可以知道，兩個對象的地址是一樣，也就是說p1指向了新的對象，而不是把原來的對象的地址賦給p1。

3 深拷貝和淺拷貝

public class Person implements Cloneable{
    private String name;
    private int age;

    public Person(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException { return super.clone(); }
    
    

}

上面的示例代碼中，Person中有兩個成員變量，分別是name和age， name是String類型， age是int類型。由於age是基本數據類型， 那么對它的拷貝沒有什么疑議，直接將一個4字節的整數值拷貝過來就行。但是name是String類型的， 它只是一個引用， 指向一個真正的String對象，那么對它的拷貝有兩種方式： 直接將源對象中的name的引用值拷貝給新對象的name字段， 或者是根據原Person對象中的name指向的字符串對象創建一個新的相同的字符串對象，將這個新字符串對象的引用賦給新拷貝的Person對象的name字段。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示：由於age是基本數據類型， 那么對它的拷貝沒有什么疑議，直接將一個4字節的整數值拷貝過來就行。但是name是String類型的， 它只是一個引用， 指向一個真正的String對象，那么對它的拷貝有兩種方式： 直接將源對象中的name的引用值拷貝給新對象的name字段， 或者是根據原Person對象中的name指向的字符串對象創建一個新的相同的字符串對象，將這個新字符串對象的引用賦給新拷貝的Person對象的name字段。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示：

下面通過代碼進行驗證。如果兩個Person對象的name的地址值相同， 說明兩個對象的name都指向同一個String對象， 也就是淺拷貝， 而如果兩個對象的name的地址值不同， 那么就說明指向不同的String對象， 也就是在拷貝Person對象的時候， 同時拷貝了name引用的String對象， 也就是深拷貝。驗證代碼如下：

測試：

public static void main(String[] args) {
        Person p = new Person(23, "zhang");
        Person p1 = null;
        try {
            p1 = (Person) p.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        String result = p.getName() == p1.getName() ? //
            "clone是淺拷貝的": "clone是深拷貝的";
        System.out.println(result);
    }

運行結果：

clone是淺拷貝的

所以，clone方法執行的是淺拷貝， 在編寫程序時要注意這個細節

 

3.1 覆蓋Object中的clone方法， 實現深拷貝

現在為了要在clone對象時進行深拷貝， 那么就要Clonable接口，覆蓋並實現clone方法，除了調用父類中的clone方法得到新的對象， 還要將該類中的引用變量也clone出來。如果只是用Object中默認的clone方法，是淺拷貝的，再次以下面的代碼驗證：

static class Body implements Cloneable{  
    public Head head;  
    public Body() {}  
    public Body(Head head) {this.head = head;}  
  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        Body newBody =  (Body) super.clone();  
        newBody.head = (Head) head.clone();  
        return newBody;  
    }  
      
}  
static class Head implements Cloneable{  
    public  Face face;  
      
    public Head() {}  
    public Head(Face face){this.face = face;}  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return super.clone();  
    }  
}   
public static void main(String[] args) throws CloneNotSupportedException {  
      
    Body body = new Body(new Head());        
    Body body1 = (Body) body.clone();  
    System.out.println("body == body1 : " + (body == body1) );        
    System.out.println("body.head == body1.head : " +  (body.head == body1.head));    
}

在以上代碼中， 有兩個主要的類， 分別為Body和Face， 在Body類中， 組合了一個Face對象。當對Body對象進行clone時， 它組合的Face對象只進行淺拷貝。打印結果可以驗證該結論：

body == body1 : false
body.head == body1.head : true

如果要使Body對象在clone時進行深拷貝， 那么就要在Body的clone方法中，將源對象引用的Head對象也clone一份。

static class Body implements Cloneable{  
    public Head head;  
    public Body() {}  
    public Body(Head head) {this.head = head;}  
  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        Body newBody =  (Body) super.clone();  
        newBody.head = (Head) head.clone();  
        return newBody;  
    }  
      
}  
static class Head implements Cloneable{  
    public  Face face;  
      
    public Head() {}  
    public Head(Face face){this.face = face;}  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return super.clone();  
    }  
}   
public static void main(String[] args) throws CloneNotSupportedException {  
      
    Body body = new Body(new Head());       
    Body body1 = (Body) body.clone();       
    System.out.println("body == body1 : " + (body == body1) );       
    System.out.println("body.head == body1.head : " +  (body.head == body1.head));     
}

打印結果為：

body == body1 : false
body.head == body1.head : false

由此可見， body和body1內的head引用指向了不同的Head對象， 也就是說在clone Body對象的同時， 也拷貝了它所引用的Head對象， 進行了深拷貝。

3.2 上面的例子不一定是真拷貝

由上一節的內容可以得出如下結論：如果想要深拷貝一個對象， 這個對象必須要實現Cloneable接口，實現clone方法，並且在clone方法內部，把該對象引用的其他對象也要clone一份 ， 這就要求這個被引用的對象必須也要實現Cloneable接口並且實現clone方法。

那么，按照上面的結論， Body類組合了Head類， 而Head類組合了Face類，要想深拷貝Body類，必須在Body類的clone方法中將Head類也要拷貝一份，但是在拷貝Head類時，默認執行的是淺拷貝，也就是說Head中組合的Face對象並不會被拷貝。驗證代碼如下：（這里本來只給出Face類的代碼就可以了， 但是為了閱讀起來具有連貫性，避免丟失上下文信息， 還是給出整個程序，整個程序也非常簡短）

static class Body implements Cloneable{  
    public Head head;  
    public Body() {}  
    public Body(Head head) {this.head = head;}  
  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        Body newBody =  (Body) super.clone();  
        newBody.head = (Head) head.clone();  
        return newBody;  
    }  
      
}  
  
static class Head implements Cloneable{  
    public  Face face;  
      
    public Head() {}  
    public Head(Face face){this.face = face;}  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return super.clone();  
    }  
}   
  
static class Face{}  
  
public static void main(String[] args) throws CloneNotSupportedException {  
      
    Body body = new Body(new Head(new Face()));        
    Body body1 = (Body) body.clone();        
    System.out.println("body == body1 : " + (body == body1) );        
    System.out.println("body.head == body1.head : " +  (body.head == body1.head));        
    System.out.println("body.head.face == body1.head.face : " +  (body.head.face == body1.head.face));      
}

結果：

body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : true

內存結構圖：

那么，對Body對象來說，算是這算是深拷貝嗎？其實應該算是深拷貝，因為對Body對象內所引用的其他對象（目前只有Head）都進行了拷貝，也就是說兩個獨立的Body對象內的head引用已經指向了獨立的兩個Head對象。但是，這對於兩個Head對象來說，他們指向了同一個Face對象，這就說明，兩個Body對象還是有一定的聯系，並沒有完全的獨立。這應該說是一種不徹底的深拷貝。

3.3 進行徹底的深拷貝

對於上面的例子來說，怎樣才能保證兩個Body對象完全獨立呢？只要在拷貝Head對象的時候，也將Face對象拷貝一份就可以了。這需要讓Face類也實現Cloneable接口，實現clone方法，並且在在Head對象的clone方法中，拷貝它所引用的Face對象。修改的部分代碼如下：

static class Head implements Cloneable{  
    public  Face face;  
      
    public Head() {}  
    public Head(Face face){this.face = face;}  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        //return super.clone();  
        Head newHead = (Head) super.clone();  
        newHead.face = (Face) this.face.clone();  
        return newHead;  
    }  
}   
  
static class Face implements Cloneable{  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return super.clone();  
    }  
}

再次運行上面的示例，得到的運行結果如下：

body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : false

這說名兩個Body已經完全獨立了，他們間接引用的face對象已經被拷貝，也就是引用了獨立的Face對象。內存結構圖如下：

依此類推，如果Face對象還引用了其他的對象， 比如說Mouth，如果不經過處理，Body對象拷貝之后還是會通過一級一級的引用，引用到同一個Mouth對象。同理， 如果要讓Body在引用鏈上完全獨立， 只能顯式的讓Mouth對象也被拷貝。

到此，可以得到如下結論：如果在拷貝一個對象時，要想讓這個拷貝的對象和源對象完全彼此獨立，那么在引用鏈上的每一級對象都要被顯式的拷貝。所以創建徹底的深拷貝是非常麻煩的，尤其是在引用關系非常復雜的情況下， 或者在引用鏈的某一級上引用了一個第三方的對象， 而這個對象沒有實現clone方法， 那么在它之后的所有引用的對象都是被共享的。 舉例來說，如果被Head引用的Face類是第三方庫中的類，並且沒有實現Cloneable接口，那么在Face之后的所有對象都會被拷貝前后的兩個Body對象共同引用。假設Face對象內部組合了Mouth對象，並且Mouth對象內部組合了Tooth對象， 內存結構如下圖：

參考：

1、http://blog.csdn.net/pandajava/article/details/42042325

2、http://blog.csdn.net/zhangjg_blog/article/details/18369201/