Java中對象的建立
clone 顧名思義就是 複制 ， 在Java語言中， clone方法被對象調用，是以會複制對象。所謂的複制對象，首先要配置設定一個和源對象同樣大小的空間，在這個空間中建立一個新的對象。
我們回顧一下：在java語言中，有幾種方式可以建立對象呢？
使用new操作符建立一個對象
使用clone方法複制一個對象
那麼這兩種方式有什麼相同和不同呢？
new操作符的本意是配置設定記憶體。程式執行到new操作符時， 首先去看new操作符後面的類型，因為知道了類型，才能知道要配置設定多大的記憶體空間。配置設定完記憶體之後，再調用構造函數，填充對象的各個域，這一步叫做對象的初始化，構造方法傳回後，一個對象建立完畢，可以把他的引用（位址）釋出到外部，在外部就可以使用這個引用操縱這個對象。
而clone在第一步是和new相似的， 都是配置設定記憶體，調用clone方法時，配置設定的記憶體和源對象（即調用clone方法的對象）相同，然後再使用原對象中對應的各個域，填充新對象的域， 填充完成之後，clone方法傳回，一個新的相同的對象被建立，同樣可以把這個新對象的引用釋出到外部 。
複制對象 or 複制引用
在Java中，以下類似的代碼非常常見：
Person p = new Person(23, "zhang");
Person p1 = p;
System.out.println(p);
System.out.println(p1); 列印結果：
com.pansoft.zhangjg.testclone.Person@2f9ee1accom.pansoft.zhangjg.testclone.Person@2f9ee1ac 可以看出，列印的位址值是相同的，既然位址都是相同的，那麼肯定是同一個對象。p和p1隻是引用而已，他們都指向了一個相同的對象Person(23, "zhang") 。 可以把這種現象叫做 引用的複制 。
上面代碼執行完成之後， 記憶體中的情景如下圖所示：
而下面的代碼是真真正正的克隆了一個對象：
Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
System.out.println(p);
System.out.println(p1); 列印結果:
com.pansoft.zhangjg.testclone.Person@2f9ee1accom.pansoft.zhangjg.testclone.Person@67f1fba0 上代碼執行完成後， 記憶體中的情景如下圖所示：
深拷貝 or 淺拷貝
上面的示例代碼中，Person中有兩個成員變量，分别是name和age， name是String類型， age是int類型。代碼非常簡單，如下所示：
public class Person implements Cloneable
{
private int age ;
private String name;
public Person(int age, String name)
{
this.age = age;
this.name = name;
}
public Person()
{}
public int getAge()
{
return age;
}
public String getName()
{
return name;
} @
Override protected Object clone() throws CloneNotSupportedException
{
return (Person) super.clone();
}
} 由于age是基本資料類型， 那麼對它的拷貝沒有什麼疑議，直接将一個4位元組的整數值拷貝過來就行。但是name是String類型的， 它隻是一個引用， 指向一個真正的String對象，那麼對它的拷貝有兩種方式：
①直接将源對象中的name的引用值拷貝給新對象的name字段；
②根據原Person對象中的name指向的字元串對象建立一個新的相同的字元串對象，将這個新字元串對象的引用賦給新拷貝的Person對象的name字段。
這兩種拷貝方式分别叫做 淺拷貝 和 深拷貝 。
深拷貝和淺拷貝的原理如下圖所示：
下面通過代碼進行驗證。推薦閱讀：Java 中的 String 真的是不可變的嗎？
如果兩個Person對象的name的位址值相同， 說明兩個對象的name都指向同一個String對象， 也就是淺拷貝， 而如果兩個對象的name的位址值不同， 那麼就說明指向不同的String對象， 也就是在拷貝Person對象的時候， 同時拷貝了name引用的String對象， 也就是深拷貝。驗證代碼如下：
Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
String result = p.getName() == p1.getName() ? "clone是淺拷貝的" : "clone是深拷貝的";
System.out.println(result); clone是淺拷貝的 是以，clone方法執行的是淺拷貝， 在編寫程式時要注意這個細節。
如果想要實作深拷貝，可以通過覆寫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
{
return super.clone();
}
}
static class Head implements Cloneable
{
public Face face;
public Head()
{}
public Head(Face face)
{
this.face = face;
}
}
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 : falsebody.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 : falsebody.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類的代碼就可以了， 但是為了閱讀起來具有連貫性，避免丢失上下文資訊， 還是給出整個程式，整個程式也非常簡短）
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 : falsebody.head == body1.head : falsebody.head.face == body1.head.face : true 記憶體結構圖如下圖所示：
那麼，對Body對象來說，算是這算是深拷貝嗎？其實應該算是深拷貝，因為對Body對象内所引用的其他對象（目前隻有Head）都進行了拷貝，也就是說兩個獨立的Body對象内的head引用已經指向了獨立的兩個Head對象。
但是，這對于兩個Head對象來說，他們指向了同一個Face對象，這就說明，兩個Body對象還是有一定的聯系，并沒有完全的獨立。這應該說是一種 不徹底的深拷貝 。
如何進行徹底的深拷貝
對于上面的例子來說，怎樣才能保證兩個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 : falsebody.head == body1.head : falsebody.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的一個重要的應用也是用于不可變對象的建立。關于建立不可變對象，我會在後續的文章中進行闡述，敬請期待。