1 什么是 Clone ，容易實現嗎？
簡單地說， Clone 就是對于給定的一個對象實例 o ，得到另一個對象實例 o’ ： o 與 o’ 類
型相同（ o.getClass() == o’.getClass() ），內容相同（對于 o/o’ 中的字段 f ，如果 f 是基本數據類型，則 o.f == o’.f ；如果 f 是對象引用，則 o.f == o’.f 或 o.f 指向的對象與 o’.f 指向的對象的內容相同）。通常稱 o’ 為 o 的克隆或副本。
直觀上看，似乎很容易為一個類加上 clone 方法：
|
class A {
private Type1 field1;
private Type2 field2;
…..
public Object clone() {
A a = new A();
a.field1 = a.getField1();
a.field2 = a.getField2();
……
return a;
}
}
|
然而，稍加推敲，就會發現這樣的實現方法有兩個問題：
1. 要想某個類有 clone 功能，必須單獨為其實現 clone() 函數，函數實現代碼與該類定義密切相關。
2. 即使基類 A 已有 clone() 函數，其子類 ExtendA 若要具備 clone 功能，則必須 override 其基類 A 的 clone() 函數。否則，對類型為 ExtendA 的對象 ea 的 clone() 方法的調用，會執行于類 A 中定義的 clone() 方法而返回一個類型為 A 的對象，它顯然不是 ea 的克隆。
2 Java 對 clone 的支持
萬類之初的 Object 類有 clone() 方法：
|
protected native Object clone() throws CloneNotSupportedException;
|
該方法是 protected 的，顯然是留待被子類 override 的。該方法又是 native 的，必然做了
與具體平臺相關的底層工作。
事實上，類 Object 的 clone() 方法首先會檢查 this.getClass() 是否實現了 Cloneable 接口。
Cloneable 只是一個標志接口而已，用來標志該類是否有克隆功能。
|
public interface Cloneable {
}
|
如果 this.getClass() 沒有實現 Cloneable 接口， clone() 就會拋 CloneNotSupportedException 返回。否則就會創建一個類型為 this.getClass() 的對象 other ，并將 this 各 field 的值賦值給 other 的對應 field ，然后返回 other 。
如此一來，我們要定義一個具有 Clone 功能的類就相當方便：
1. 在類的聲明中加入“ implements Cloneable ”，標志該類有克隆功能；
2. Override 類 Object 的 clone() 方法，在該方法中調用 super.clone() ：
|
class CloneableClass implements Cloneable {
……
public Object clone() {
try {
return super.clone(); // 直接讓 Object.clone() 為我們代勞一切
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
}
|
3 Shallow Clone 與 Deep Clone
3.1 Shallow 與 Deep 從何而來
一個具有克隆功能的類，如果有可變（ Mutable ）類類型的字段 field ，如何為其克隆（副
本）對象 o’ 中的 field 賦值？
方法一、如 Object 的 clone() 方法所實現：設原始對象為 o ，其克隆對象是 o’ ，執行 o’.field = o.field 。這樣， o’.field 與 o.field 指向同一個可變對象 m 。 o 與 o’ 可能會相互影響（一個對象的狀態可能會隨著另一個對象的狀態的改變而改變）。這樣的 Clone 稱為 Shallow Clone 。這也是 Object 的 clone() 方法的實現方式。
方法二、將 o.field 指向的可變對象 m 克隆，得到 m’ ，將 m’ 的引用賦值給 o’.field 。這樣 o’ 與 o 內容相同，且相互之間無影響（一個對象狀態的改變不會影響另一個對象的狀態）。這樣的 Clone 稱為 Deep Clone 。
Java Collection 類庫中具體數據結構類（ ArrayList/LinkedList ， HashSet/TreeSet ， HashMap/TreeMap 等）都具有克隆功能，且都是 Shallow Clone ，這樣設計是合理的，因為它們不知道存放其中的每個數據對象是否也有克隆功能。 System.arrayCopy() 的實現采用的也是 Shallow Clone 。
Deep Clone 對于實現不可變（ Immutable ）類很有幫助。設一個類包含可變類 M 類型的 field ，如何將其設計為不可變類呢？先為 M 實現 Deep Clone 功能，然后這樣設計類 ImmutableClass ：
|
class ImmutableClass {
MutableClass m;
ImmutableClass(MutableClass m) {
this.m = m.clone(); // 將傳入的 m 的 clone 賦值給內部 m
}
public MutableClass getM() {
return this.m.clone(); // 將內部 m 的 clone 返回給外部
}
}
|
3.2 如何實現 Deep Clone
檢查類有無可變類類型的字段。如果無，返回 super.clone() 即可；
如果有，確保包含的可變類本身都實現了 Deep Clone ；
Object o = super.clone(); // 先執行淺克隆，確保類型正確和基本類型及非可變類類型字段內容正確
對于每一個可變類類型的字段 field ：
o.field = this.getField().clone();
返回 o 。