深入淺出Java中的clone克隆方法，寫得太棒了！

作者：張紀剛

blog.csdn.net/zhangjg_blog/article/details/18369201/

Java中物件的建立

clone 顧名思義就是 複製 ， 在Java語言中， clone方法被物件呼叫，所以會複製物件。所謂的複製物件，首先要分配一個和源物件同樣大小的空間，在這個空間中建立一個新的物件。

我們回顧一下：在java語言中，有幾種方式可以建立物件呢？

1. 使用new運運算元建立一個物件
2. 使用clone方法複製一個物件

那麼這兩種方式有什麼相同和不同呢？

new運運算元的本意是分配記憶體。程式執行到new運運算元時， 首先去看new運運算元後面的型別，因為知道了型別，才能知道要分配多大的記憶體空間。分配完記憶體之後，再呼叫建構式，填充物件的各個域，這一步叫做物件的初始化，構造方法傳回後，一個物件建立完畢，可以把他的取用（地址）釋出到外部，在外部就可以使用這個取用操縱這個物件。

而clone在第一步是和new相似的， 都是分配記憶體，呼叫clone方法時，分配的記憶體和源物件（即呼叫clone方法的物件）相同，然後再使用原物件中對應的各個域，填充新物件的域， 填充完成之後，clone方法傳回，一個新的相同的物件被建立，同樣可以把這個新物件的取用釋出到外部 。

複製物件 or 複製取用

在Java中，以下類似的程式碼非常常見：

1. 1. Person p = new Person(23, "zhang");  
2.  
3. 2. Person p1 = p;
4.  
5. 4. System.out.println(p);  
6.  
7. 5. System.out.println(p1);  

列印結果：

1. 1. com.pansoft.zhangjg.testclone.Person@2f9ee1ac
2. 2. com.pansoft.zhangjg.testclone.Person@2f9ee1ac

可以看出，列印的地址值是相同的，既然地址都是相同的，那麼肯定是同一個物件。p和p1只是取用而已，他們都指向了一個相同的物件Person(23, “zhang”) 。 可以把這種現象叫做 取用的複製 。

上面程式碼執行完成之後， 記憶體中的情景如下圖所示：

而下麵的程式碼是真真正正的克隆了一個物件：

1. 1. Person p = new Person(23, "zhang");  
2.  
3. 2. Person p1 = (Person) p.clone();  
4.  
5. 4. System.out.println(p);  
6.  
7. 5. System.out.println(p1);

列印結果:

1. 1. com.pansoft.zhangjg.testclone.Person@2f9ee1ac
2.  
3. 2. com.pansoft.zhangjg.testclone.Person@67f1fba0

以上程式碼執行完成後， 記憶體中的情景如下圖所示：

深複製 or 淺複製

上面的示例程式碼中，Person中有兩個成員變數，分別是name和age， name是String型別， age是int型別。程式碼非常簡單，如下所示：

1. 1. public class Person implements Cloneable{  
2.  
3. 3.    private int age ;
4.  
5. 4.    private String name;
6.  
7. 6.    public Person(int age, String name) {
8.  
9. 7.        this.age = age;  
10.  
11. 8.        this.name = name;  
12.  
13. 9.    }  
14.  
15. 11.    public Person() {}  
16.  
17. 13.    public int getAge() {
18.  
19. 14.        return age;
20.  
21. 15.    }  
22.  
23. 17.    public String getName() {
24.  
25. 18.        return name;
26.  
27. 19.    }  
28.  
29. 21. @Override
30.  
31. 22.    protected Object clone() throws CloneNotSupportedException {
32.  
33. 23.        return (Person)super.clone();  
34.  
35. 24.    }  
36.  
37. 25. }  

由於age是基本資料型別， 那麼對它的複製沒有什麼疑議，直接將一個4位元組的整數值複製過來就行。但是name是String型別的， 它只是一個取用， 指向一個真正的String物件，那麼對它的複製有兩種方式：

①直接將源物件中的name的取用值複製給新物件的name欄位；

②根據原Person物件中的name指向的字串物件建立一個新的相同的字串物件，將這個新字串物件的取用賦給新複製的Person物件的name欄位。

這兩種複製方式分別叫做 淺複製 和 深複製 。

深複製和淺複製的原理如下圖所示：

下麵透過程式碼進行驗證。推薦閱讀：Java 中的 String 真的是不可變的嗎？

如果兩個Person物件的name的地址值相同， 說明兩個物件的name都指向同一個String物件， 也就是淺複製， 而如果兩個物件的name的地址值不同， 那麼就說明指向不同的String物件， 也就是在複製Person物件的時候， 同時複製了name取用的String物件， 也就是深複製。驗證程式碼如下：

1. 1. Person p = new Person(23, "zhang");  
2.  
3. 2. Person p1 = (Person) p.clone();  
4.  
5. 4. String result = p.getName() == p1.getName()
6.  
7. 5. ? "clone是淺複製的" : "clone是深複製的";  
8.  
9. 7. System.out.println(result);  

列印結果:

1. clone是淺複製的

所以，clone方法執行的是淺複製， 在編寫程式時要註意這個細節。

如果想要實現深複製，可以透過改寫Object中的clone方法的方式。

現在為了要在clone物件時進行深複製， 那麼就要Clonable介面，改寫並實現clone方法，除了呼叫父類中的clone方法得到新的物件， 還要將該類中的取用變數也clone出來。如果只是用Object中預設的clone方法，是淺複製的，再次以下麵的程式碼驗證：

1. 1. static class Body implements Cloneable{  
2.  
3. 2.    public Head head;
4.  
5. 4.    public Body() {}  
6.  
7. 6.    public Body(Head head) {this.head = head;}  
8.  
9. 8. @Override
10.  
11. 9.    protected Object clone() throws CloneNotSupportedException {
12.  
13. 10.        return super.clone();  
14.  
15. 11.    }  
16.  
17. 13. }  
18.  
19. 14. static class Head /*implements Cloneable*/{  
20.  
21. 15.    public Face face;
22.  
23. 17.    public Head() {}  
24.  
25. 18.    public Head(Face face){this.face = face;}  
26.  
27. 20. }  
28.  
29. 21. public static void main(String[] args) throws CloneNotSupportedException {
30.  
31. 23.    Body body = new Body(new Head());  
32.  
33. 25.    Body body1 = (Body) body.clone();  
34.  
35. 27.    System.out.println("body == body1 : " + (body == body1) );
36.  
37. 29.    System.out.println("body.head == body1.head : " +  (body.head == body1.head));
38.  
39. 32. }  

在以上程式碼中， 有兩個主要的類， 分別為Body和Face， 在Body類中， 組合了一個Face物件。當對Body物件進行clone時， 它組合的Face物件只進行淺複製。列印結果可以驗證該結論：

1. 1. body == body1 : false
2.  
3. 2. body.head == body1.head : true

如果要使Body物件在clone時進行深複製， 那麼就要在Body的clone方法中，將源物件取用的Head物件也clone一份。

1. 1. static class Body implements Cloneable{  
2.  
3. 2.    public Head head;
4.  
5. 3.    public Body() {}  
6.  
7. 4.    public Body(Head head) {this.head = head;}  
8.  
9. 6. @Override
10.  
11. 7.    protected Object clone() throws CloneNotSupportedException {
12.  
13. 8.        Body newBody =  (Body) super.clone();  
14.  
15. 9.        newBody.head = (Head) head.clone();  
16.  
17. 10.        return newBody;
18.  
19. 11.    }  
20.  
21. 13. }  
22.  
23. 14. static class Head implements Cloneable{  
24.  
25. 15.    public Face face;
26.  
27. 17.    public Head() {}  
28.  
29. 18.    public Head(Face face){this.face = face;}  
30.  
31. 19. @Override
32.  
33. 20.    protected Object clone() throws CloneNotSupportedException {
34.  
35. 21.        return super.clone();  
36.  
37. 22.    }  
38.  
39. 23. }  
40.  
41. 24. public static void main(String[] args) throws CloneNotSupportedException {
42.  
43. 26.    Body body = new Body(new Head());  
44.  
45. 28.    Body body1 = (Body) body.clone();  
46.  
47. 30.    System.out.println("body == body1 : " + (body == body1) );
48.  
49. 32.    System.out.println("body.head == body1.head : " +  (body.head == body1.head));
50.  
51. 35. }  

列印結果:

1. 1. body == body1 : false
2.  
3. 2. body.head == body1.head : false

由此可見， body和body1內的head取用指向了不同的Head物件， 也就是說在clone Body物件的同時， 也複製了它所取用的Head物件， 進行了深複製。

真的是深複製嗎

透過上面的講解我們已經知道： 如果想要深複製一個物件， 這個物件必須要實現Cloneable介面，實現clone方法，並且在clone方法內部，把該物件取用的其他物件也要clone一份 ， 這就要求這個被取用的物件必須也要實現Cloneable介面並且實現clone方法。

那麼，按照上面的結論， Body類組合了Head類， 而Head類組合了Face類，要想深複製Body類，必須在Body類的clone方法中將Head類也要複製一份，但是在複製Head類時，預設執行的是淺複製，也就是說Head中組合的Face物件並不會被複製。

驗證程式碼如下：（這裡本來只給出Face類的程式碼就可以了， 但是為了閱讀起來具有連貫性，避免丟失背景關係資訊， 還是給出整個程式，整個程式也非常簡短）

1. 1. static class Body implements Cloneable{  
2.  
3. 2.    public Head head;
4.  
5. 3.    public Body() {}  
6.  
7. 4.    public Body(Head head) {this.head = head;}  
8.  
9. 6. @Override
10.  
11. 7.    protected Object clone() throws CloneNotSupportedException {
12.  
13. 8.        Body newBody =  (Body) super.clone();  
14.  
15. 9.        newBody.head = (Head) head.clone();  
16.  
17. 10.        return newBody;
18.  
19. 11.    }  
20.  
21. 13. }  
22.  
23. 15. static class Head implements Cloneable{  
24.  
25. 16.    public Face face;
26.  
27. 18.    public Head() {}  
28.  
29. 19.    public Head(Face face){this.face = face;}  
30.  
31. 20. @Override
32.  
33. 21.    protected Object clone() throws CloneNotSupportedException {
34.  
35. 22.        return super.clone();  
36.  
37. 23.    }  
38.  
39. 24. }  
40.  
41. 26. static class Face{}  
42.  
43. 28. public static void main(String[] args) throws CloneNotSupportedException {
44.  
45. 30.    Body body = new Body(new Head(new Face()));  
46.  
47. 32.    Body body1 = (Body) body.clone();  
48.  
49. 34.    System.out.println("body == body1 : " + (body == body1) );
50.  
51. 36.    System.out.println("body.head == body1.head : " +  (body.head == body1.head));
52.  
53. 38.    System.out.println("body.head.face == body1.head.face : " +  (body.head.face == body1.head.face));
54.  
55. 41. }  

列印結果:

1. 1. body == body1 : false
2.  
3. 2. body.head == body1.head : false
4.  
5. 3. body.head.face == body1.head.face : true

記憶體結構圖如下圖所示：

那麼，對Body物件來說，算是這算是深複製嗎？其實應該算是深複製，因為對Body物件內所取用的其他物件（目前只有Head）都進行了複製，也就是說兩個獨立的Body物件內的head取用已經指向了獨立的兩個Head物件。

但是，這對於兩個Head物件來說，他們指向了同一個Face物件，這就說明，兩個Body物件還是有一定的聯絡，並沒有完全的獨立。這應該說是一種 不徹底的深複製 。

如何進行徹底的深複製

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

1. 1. static class Head implements Cloneable{  
2.  
3. 2.    public Face face;
4.  
5. 4.    public Head() {}  
6.  
7. 5.    public Head(Face face){this.face = face;}  
8.  
9. 6. @Override
10.  
11. 7.    protected Object clone() throws CloneNotSupportedException {
12.  
13. 8.        //return super.clone();  
14.  
15. 9.        Head newHead = (Head) super.clone();  
16.  
17. 10.        newHead.face = (Face) this.face.clone();  
18.  
19. 11.        return newHead;
20.  
21. 12.    }  
22.  
23. 13. }  
24.  
25. 15. static class Face implements Cloneable{  
26.  
27. 16. @Override
28.  
29. 17.    protected Object clone() throws CloneNotSupportedException {
30.  
31. 18.        return super.clone();  
32.  
33. 19.    }  
34.  
35. 20. }  

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

1. 1. body == body1 : false
2.  
3. 2. body.head == body1.head : false
4.  
5. 3. 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物件， 記憶體結構如下圖：

寫在最後

clone在平時專案的開發中可能用的不是很頻繁，但是區分深複製和淺複製會讓我們對java記憶體結構和執行方式有更深的瞭解。至於徹底深複製，幾乎是不可能實現的，原因已經在上一節中進行了說明。

深複製和徹底深複製，在建立不可變物件時，可能對程式有著微妙的影響，可能會決定我們建立的不可變物件是不是真的不可變。clone的一個重要的應用也是用於不可變物件的建立。關於建立不可變物件，我會在後續的文章中進行闡述，敬請期待。