Java中對象的創(chuàng)建
clone顧名思義就是復制麻惶， 在Java語言中喇嘱， clone方法被對象調(diào)用，所以會復制對象款熬。所謂的復制對象深寥，首先要分配一個和源對象同樣大小的空間，在這個空間中創(chuàng)建一個新的對象贤牛。那么在java語言中，有幾種方式可以創(chuàng)建對象呢则酝？
- 使用new操作符創(chuàng)建一個對象
- 使用clone方法復制一個對象
那么這兩種方式有什么相同和不同呢殉簸？ new操作符的本意是分配內(nèi)存闰集。程序執(zhí)行到new操作符時， 首先去看new操作符后面的類型般卑，因為知道了類型武鲁，才能知道要分配多大的內(nèi)存空間。分配完內(nèi)存之后蝠检，再調(diào)用構造函數(shù)沐鼠，填充對象的各個域，這一步叫做對象的初始化叹谁，構造方法返回后饲梭，一個對象創(chuàng)建完畢，可以把他的引用（地址）發(fā)布到外部焰檩，在外部就可以使用這個引用操縱這個對象憔涉。而clone在第一步是和new相似的， 都是分配內(nèi)存析苫，調(diào)用clone方法時兜叨，分配的內(nèi)存和源對象（即調(diào)用clone方法的對象）相同，然后再使用原對象中對應的各個域衩侥，填充新對象的域国旷， 填充完成之后，clone方法返回茫死，一個新的相同的對象被創(chuàng)建议街，同樣可以把這個新對象的引用發(fā)布到外部。
復制對象 or 復制引用
在Java中璧榄，以下類似的代碼非常常見：
Person p = new Person(23, "zhang");
Person p1 = p;
System.out.println(p);
System.out.println(p1);
當Person p1 = p;執(zhí)行之后特漩， 是創(chuàng)建了一個新的對象嗎？ 首先看打印結果：
com.pansoft.zhangjg.testclone.Person@2f9ee1ac
com.pansoft.zhangjg.testclone.Person@2f9ee1ac
可已看出骨杂，打印的地址值是相同的涂身，既然地址都是相同的，那么肯定是同一個對象搓蚪。p和p1只是引用而已蛤售，他們都指向了一個相同的對象Person(23, "zhang") 。 可以把這種現(xiàn)象叫做引用的復制妒潭。 上面代碼執(zhí)行完成之后悴能， 內(nèi)存中的情景如下圖所示：
而下面的代碼是真真正正的克隆了一個對象。
Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
System.out.println(p);
System.out.println(p1)
從打印結果可以看出雳灾，兩個對象的地址是不同的漠酿，也就是說創(chuàng)建了新的對象， 而不是把原對象的地址賦給了一個新的引用變量：
com.pansoft.zhangjg.testclone.Person@2f9ee1ac
com.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是基本數(shù)據(jù)類型， 那么對它的拷貝沒有什么疑議夭拌，直接將一個4字節(jié)的整數(shù)值拷貝過來就行魔熏。但是name是String類型的， 它只是一個引用鸽扁， 指向一個真正的String對象蒜绽，那么對它的拷貝有兩種方式： 直接將源對象中的name的引用值拷貝給新對象的name字段， 或者是根據(jù)原Person對象中的name指向的字符串對象創(chuàng)建一個新的相同的字符串對象献烦，將這個新字符串對象的引用賦給新拷貝的Person對象的name字段滓窍。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示：
下面通過代碼進行驗證巩那。如果兩個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方法執(zhí)行的是淺拷貝桨嫁， 在編寫程序時要注意這個細節(jié)。
覆蓋Object中的clone方法份帐， 實現(xiàn)深拷貝
現(xiàn)在為了要在clone對象時進行深拷貝璃吧， 那么就要Clonable接口，覆蓋并實現(xiàn)clone方法废境，除了調(diào)用父類中的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 : 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內(nèi)的head引用指向了不同的Head對象戴涝， 也就是說在clone Body對象的同時， 也拷貝了它所引用的Head對象钻蔑， 進行了深拷貝啥刻。
真的是深拷貝嗎
由上一節(jié)的內(nèi)容可以得出如下結論：如果想要深拷貝一個對象， 這個對象必須要實現(xiàn)Cloneable接口咪笑，實現(xiàn)clone方法可帽，并且在clone方法內(nèi)部，把該對象引用的其他對象也要clone一份 窗怒， 這就要求這個被引用的對象必須也要實現(xiàn)Cloneable接口并且實現(xiàn)clone方法映跟。
那么，按照上面的結論扬虚， Body類組合了Head類努隙， 而Head類組合了Face類，要想深拷貝Body類辜昵，必須在Body類的clone方法中將Head類也要拷貝一份荸镊，但是在拷貝Head類時，默認執(zhí)行的是淺拷貝堪置，也就是說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
內(nèi)存結構圖如下圖所示：
那么雁竞，對Body對象來說钦椭，算是這算是深拷貝嗎？其實應該算是深拷貝碑诉，因為對Body對象內(nèi)所引用的其他對象（目前只有Head）都進行了拷貝彪腔，也就是說兩個獨立的Body對象內(nèi)的head引用已經(jīng)指向了獨立的兩個Head對象。但是进栽，這對于兩個Head對象來說德挣，他們指向了同一個Face對象，這就說明快毛，兩個Body對象還是有一定的聯(lián)系格嗅，并沒有完全的獨立番挺。這應該說是一種不徹底的深拷貝。
如何進行徹底的深拷貝
對于上面的例子來說屯掖，怎樣才能保證兩個Body對象完全獨立呢玄柏？只要在拷貝Head對象的時候，也將Face對象拷貝一份就可以了贴铜。這需要讓Face類也實現(xiàn)Cloneable接口粪摘，實現(xiàn)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已經(jīng)完全獨立了轩褐，他們間接引用的face對象已經(jīng)被拷貝椎咧，也就是引用了獨立的Face對象。內(nèi)存結構圖如下：
依此類推把介，如果Face對象還引用了其他的對象勤讽， 比如說Mouth，如果不經(jīng)過處理劳澄，Body對象拷貝之后還是會通過一級一級的引用地技，引用到同一個Mouth對象。同理秒拔， 如果要讓Body在引用鏈上完全獨立莫矗， 只能顯式的讓Mouth對象也被拷貝。
到此砂缩，可以得到如下結論：如果在拷貝一個對象時作谚，要想讓這個拷貝的對象和源對象完全彼此獨立，那么在引用鏈上的每一級對象都要被顯式的拷貝庵芭。所以創(chuàng)建徹底的深拷貝是非常麻煩的妹懒，尤其是在引用關系非常復雜的情況下， 或者在引用鏈的某一級上引用了一個第三方的對象双吆， 而這個對象沒有實現(xiàn)clone方法眨唬， 那么在它之后的所有引用的對象都是被共享的。 舉例來說好乐，如果被Head引用的Face類是第三方庫中的類匾竿，并且沒有實現(xiàn)Cloneable接口，那么在Face之后的所有對象都會被拷貝前后的兩個Body對象共同引用蔚万。假設Face對象內(nèi)部組合了Mouth對象岭妖，并且Mouth對象內(nèi)部組合了Tooth對象， 內(nèi)存結構如下圖：
總結
clone在平時項目的開發(fā)中可能用的不是很頻繁，但是區(qū)分深拷貝和淺拷貝會讓我們對java內(nèi)存結構和運行方式有更深的了解昵慌。至于徹底深拷貝假夺，幾乎是不可能實現(xiàn)的，原因已經(jīng)在上一節(jié)中進行了說明斋攀。深拷貝和徹底深拷貝已卷，在創(chuàng)建不可變對象時，可能對程序有著微妙的影響蜻韭，可能會決定我們創(chuàng)建的不可變對象是不是真的不可變悼尾。clone的一個重要的應用也是用于不可變對象的創(chuàng)建柿扣。關于創(chuàng)建不可變對象肖方，我會在后續(xù)的文章中進行闡述，敬請期待未状。
