Java中對象的創(chuàng)建

clone顧名思義就是復(fù)制， 在Java語言中， clone方法被對象調(diào)用，所以會復(fù)制對象。所謂的復(fù)制對象，首先要分配一個和源對象同樣大小的空間，在這個空間中創(chuàng)建一個新的對象。那么在java語言中，有幾種方式可以創(chuàng)建對象呢？

1 使用new操作符創(chuàng)建一個對象

2 使用clone方法復(fù)制一個對象

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

new操作符的本意是分配內(nèi)存。程序執(zhí)行到new操作符時，

首先去看new操作符后面的類型，因為知道了類型，才能知道要分配多大的內(nèi)存空間。分配完內(nèi)存之后，再調(diào)用構(gòu)造函數(shù)，填充對象的各個域，這一步叫做對象的

初始化，構(gòu)造方法返回后，一個對象創(chuàng)建完畢，可以把他的引用(地址)發(fā)布到外部，在外部就可以使用這個引用操縱這個對象。而clone在第一步是和new

相似的，

都是分配內(nèi)存，調(diào)用clone方法時，分配的內(nèi)存和源對象(即調(diào)用clone方法的對象)相同，然后再使用原對象中對應(yīng)的各個域，填充新對象的域，

填充完成之后，clone方法返回，一個新的相同的對象被創(chuàng)建，同樣可以把這個新對象的引用發(fā)布到外部。

復(fù)制對象 or 復(fù)制引用

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

Person?p?=?new?Person(23,?"zhang");

Person?p1?=?p;

System.out.println(p);

System.out.println(p1);

當(dāng)Person p1 = p;執(zhí)行之后， 是創(chuàng)建了一個新的對象嗎？ 首先看打印結(jié)果：

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

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

可已看出，打印的地址值是相同的，既然地址都是相同的，那么肯定是同一個對象。p和p1只是引用而已，他們都指向了一個相同的對象Person(23, "zhang") 。 可以把這種現(xiàn)象叫做引用的復(fù)制。 (關(guān)于引用和對象的區(qū)分，可以參考我之前的文章Java中的String為什么是不可變的？

-- String源碼分析?， 其中有一節(jié)講到了引用和對象的區(qū)分)。上面代碼執(zhí)行完成之后， 內(nèi)存中的情景如下圖所示：

而下面的代碼是真真正正的克隆了一個對象。

Person?p?=?new?Person(23,?"zhang");

Person?p1?=?(Person)?p.clone();

System.out.println(p);

System.out.println(p1);

從打印結(jié)果可以看出，兩個對象的地址是不同的，也就是說創(chuàng)建了新的對象， 而不是把原對象的地址賦給了一個新的引用變量：

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

com.pansoft.zhangjg.testclone.Person@67f1fba0

以上代碼執(zhí)行完成后， 內(nèi)存中的情景如下圖所示：

深拷貝 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);

打印結(jié)果為：

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對象。當(dāng)對Body對象進行clone時， 它組合的Face對象只進行淺拷貝。打印結(jié)果可以驗證該結(jié)論：

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));

}

打印結(jié)果為：

body == body1 : false

body.head == body1.head : false

由此可見， body和body1內(nèi)的head引用指向了不同的Head對象， 也就是說在clone Body對象的同時， 也拷貝了它所引用的Head對象， 進行了深拷貝。

真的是深拷貝嗎

由上一節(jié)的內(nèi)容可以得出如下結(jié)論：

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));

}

打印結(jié)果為：

body == body1 : false

body.head == body1.head : false

body.head.face == body1.head.face : true

內(nèi)存結(jié)構(gòu)圖如下圖所示：

那么，對Body對象來說，算是這算是深拷貝嗎？其實應(yīng)該算是深拷貝，因為對

Body對象內(nèi)所引用的其他對象(目前只有Head)都進行了拷貝，也就是說兩個獨立的Body對象內(nèi)的head引用已經(jīng)指向了獨立的兩個Head對象。

但是，這對于兩個Head對象來說，他們指向了同一個Face對象，這就說明，兩個Body對象還是有一定的聯(lián)系，并沒有完全的獨立。這應(yīng)該說是一種不徹底的深拷貝。

如何進行徹底的深拷貝

對于上面的例子來說，怎樣才能保證兩個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();

}

}

再次運行上面的示例，得到的運行結(jié)果如下：

body == body1 : false

body.head == body1.head : false

body.head.face == body1.head.face : false

這說名兩個Body已經(jīng)完全獨立了，他們間接引用的face對象已經(jīng)被拷貝，也就是引用了獨立的Face對象。內(nèi)存結(jié)構(gòu)圖如下：

依此類推，如果Face對象還引用了其他的對象， 比如說Mouth，如果不經(jīng)過處理，Body對象拷貝之后還是會通過一級一級的引用，引用到同一個Mouth對象。同理， 如果要讓Body在引用鏈上完全獨立， 只能顯式的讓Mouth對象也被拷貝。

到此，可以得到如下結(jié)論：如果在拷貝一個對象時，要想讓這個拷貝的對象和源對象完全彼此獨立，那么在引用鏈上的每一級對象都要被顯式的拷貝。所以創(chuàng)

建徹底的深拷貝是非常麻煩的，尤其是在引用關(guān)系非常復(fù)雜的情況下， 或者在引用鏈的某一級上引用了一個第三方的對象，

而這個對象沒有實現(xiàn)clone方法， 那么在它之后的所有引用的對象都是被共享的。

舉例來說，如果被Head引用的Face類是第三方庫中的類，并且沒有實現(xiàn)Cloneable接口，那么在Face之后的所有對象都會被拷貝前后的兩個

Body對象共同引用。假設(shè)Face對象內(nèi)部組合了Mouth對象，并且Mouth對象內(nèi)部組合了Tooth對象，

內(nèi)存結(jié)構(gòu)如下圖：

寫在最后

clone在平時項目的開發(fā)中可能用的不是很頻繁，但是區(qū)分深拷貝和淺拷貝會讓我

們對java內(nèi)存結(jié)構(gòu)和運行方式有更深的了解。至于徹底深拷貝，幾乎是不可能實現(xiàn)的，原因已經(jīng)在上一節(jié)中進行了說明。深拷貝和徹底深拷貝，在創(chuàng)建不可變對

象時，可能對程序有著微妙的影響，可能會決定我們創(chuàng)建的不可變對象是不是真的不可變。clone的一個重要的應(yīng)用也是用于不可變對象的創(chuàng)建。關(guān)于創(chuàng)建不可

變對象，我會在后續(xù)的文章中進行闡述，敬請期待。

總結(jié)

以上是生活随笔為你收集整理的java clone原理_详解Java中的clone方法 -- 原型模式的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。