什麼是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()代碼如下：
01class CloneClass implements Cloneable{
02 public int aInt;
03 public Object clone(){
04 CloneClass o = null;
05 try{
06 o = (CloneClass)super.clone();
07 }catch(CloneNotSupportedException e){
08 e.printStackTrace();
09 }
10 return o;
11 }
12}有三個值得注意的地方，一是希望能實現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異常。
注意：1.所有的數組都被視爲實現接口 Cloneable。
2.Object 類本身不實現接口 Cloneable，所以在類爲 Object 的對象上調用 clone 方法將會導致在運行時拋出異常。
以上是clone的最基本的步驟，想要完成一個成功的clone，還要了解什麼是"影子clone"和"深度clone"。
什麼是影子clone？
下面的例子包含三個類UnCloneA，CloneB，CloneMain。CloneB類包含了一個UnCloneA的實例和一個int類型變量，並且重載clone()方法。CloneMain類初始化UnCloneA類的一個實例b1，然後調用clone()方法生成了一個b1的拷貝b2。最後考察一下b1和b2的輸出：
01package clone;
02class UnCloneA {
03 private int i;
04 public UnCloneA(int ii) { i = ii; }
05 public void doubleValue() { i *= 2; }
06 public String toString() {
07 return Integer.toString(i);
08 }
09}
10class CloneB implements Cloneable{
11 public int aInt;
12 public UnCloneA unCA = new UnCloneA(111);
13 public Object clone(){
14 CloneB o = null;
15 try{
16 o = (CloneB)super.clone();
17 }catch(CloneNotSupportedException e){
18 e.printStackTrace();
19 }
20 return o;
21 }
22}
23public class CloneMain {
24 public static void main(String[] a){
25 CloneB b1 = new CloneB();
26 b1.aInt = 11;
27 System.out.println("before clone,b1.aInt = "+ b1.aInt);
28 System.out.println("before clone,b1.unCA = "+ b1.unCA);
29
30 CloneB b2 = (CloneB)b1.clone();
31 b2.aInt = 22;
32 b2.unCA.doubleValue();
33 System.out.println("=================================");
34 System.out.println("after clone,b1.aInt = "+ b1.aInt);
35 System.out.println("after clone,b1.unCA = "+ b1.unCA);
36 System.out.println("=================================");
37 System.out.println("after clone,b2.aInt = "+ b2.aInt);
38 System.out.println("after clone,b2.unCA = "+ b2.unCA);
39 }
40}
41
42
43
44/** RUN RESULT:
45before clone,b1.aInt = 11
46before clone,b1.unCA = 111
47=================================
48after clone,b1.aInt = 11
49after clone,b1.unCA = 222
50=================================
51after clone,b2.aInt = 22
52after clone,b2.unCA = 222
53*/大多時候，這種clone的結果往往不是我們所希望的結果，這種clone也被稱爲"影子clone"。要想讓b2.unCA指向與b2.unCA不同的對象，而且b2.unCA中還要包含b1.unCA中的信息作爲初始信息，就要實現深度clone。
怎麼進行深度clone？
把上面的例子改成深度clone很簡單，需要兩個改變：一是讓UnCloneA類也實現和CloneB類一樣的clone功能(實現Cloneable接口，重載clone()方法)。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();
程序如下：01package clone.ext;
02class UnCloneA implements Cloneable{
03 private int i;
04 public UnCloneA(int ii) { i = ii; }
05 public void doubleValue() { i *= 2; }
06 public String toString() {
07 return Integer.toString(i);
08 }
09 public Object clone(){
10 UnCloneA o = null;
11 try{
12 o = (UnCloneA)super.clone();
13 }catch(CloneNotSupportedException e){
14 e.printStackTrace();
15 }
16 return o;
17 }
18}
19class CloneB implements Cloneable{
20 public int aInt;
21 public UnCloneA unCA = new UnCloneA(111);
22 public Object clone(){
23 CloneB o = null;
24 try{
25 o = (CloneB)super.clone();
26 }catch(CloneNotSupportedException e){
27 e.printStackTrace();
28 }
29 o.unCA = (UnCloneA)unCA.clone();
30 return o;
31 }
32}
33public class CloneMain {
34 public static void main(String[] a){
35 CloneB b1 = new CloneB();
36 b1.aInt = 11;
37 System.out.println("before clone,b1.aInt = "+ b1.aInt);
38 System.out.println("before clone,b1.unCA = "+ b1.unCA);
39
40 CloneB b2 = (CloneB)b1.clone();
41 b2.aInt = 22;
42 b2.unCA.doubleValue();
43 System.out.println("=================================");
44 System.out.println("after clone,b1.aInt = "+ b1.aInt);
45 System.out.println("after clone,b1.unCA = "+ b1.unCA);
46 System.out.println("=================================");
47 System.out.println("after clone,b2.aInt = "+ b2.aInt);
48 System.out.println("after clone,b2.unCA = "+ b2.unCA);
49 }
50}
51/** RUN RESULT:
52before clone,b1.aInt = 11
53before clone,b1.unCA = 111
54=================================
55after clone,b1.aInt = 11
56after clone,b1.unCA = 111
57=================================
58after clone,b2.aInt = 22
59after clone,b2.unCA = 222
60*/可以看出，現在b2.unCA的改變對b1.unCA沒有產生影響。此時b1.unCA與b2.unCA指向了兩個不同的UnCloneA實例，而且在CloneB b2 = (CloneB)b1.clone();調用的那一刻b1和b2擁有相同的值，在這裏，b1.i = b2.i = 11。
要知道不是所有的類都能實現深度clone的。例如，如果把上面的CloneB類中的UnCloneA類型變量改成StringBuffer類型，看一下JDK API中關於StringBuffer的說明，StringBuffer沒有重載clone()方法，更爲嚴重的是StringBuffer還是一個final類，這也是說我們也不能用繼承的辦法間接實現StringBuffer的clone。如果一個類中包含有StringBuffer類型對象或和StringBuffer相似類的對象，我們有兩種選擇：要麼只能實現影子clone，要麼就在類的clone()方法中加一句(假設是SringBuffer對象，而且變量名仍是unCA)： o.unCA = new StringBuffer(unCA.toString()); //原來的是：o.unCA = (UnCloneA)unCA.clone();
還要知道的是除了基本數據類型能自動實現深度clone以外，String對象是一個例外，它clone後的表現好象也實現了深度clone，雖然這只是一個假象，但卻大大方便了我們的編程。
