詳解Java中的clone方法 -- 原型模式

時間  2019-11-12
標籤 詳解 java clone 方法 原型 模式 欄目 Java 简体版
原文   原文鏈接

Java中對象的建立

    clone顧名思義就是複製， 在Java語言中， clone方法被對象調用，因此會複製對象。所謂的複製對象，首先要分配一個和源對象一樣大小的空間，在這個空間中建立一個新的對象。那麼在java語言中，有幾種方式能夠建立對象呢？java

（1） 使用new操做符建立一個對象ide

（2） 使用clone方法複製一個對象函數

    那麼這兩種方式有什麼相同和不一樣呢？ new操做符的本意是分配內存。程序執行到new操做符時， 首先去看new操做符後面的類型，由於知道了類型，才能知道要分配多大的內存空間。分配完內存以後，再調用構造函數，填充對象的各個域，這一步叫作對象的初始化，構造方法返回後，一個對象建立完畢，能夠把他的引用（地址）發佈到外部，在外部就可使用這個引用操縱這個對象。而clone在第一步是和new類似的， 都是分配內存，調用clone方法時，分配的內存和源對象（即調用clone方法的對象）相同，而後再使用原對象中對應的各個域，填充新對象的域， 填充完成以後，clone方法返回，一個新的相同的對象被建立，一樣能夠把這個新對象的引用發佈到外部。源碼分析

複製對象 or 複製引用

在Java中，如下相似的代碼很是常見：this

Person p = new Person(23, "zhang");  
Person p1 = p;  
  
System.out.println(p);  
System.out.println(p1);

當Person p1 = p;執行以後， 是建立了一個新的對象嗎？ 首先看打印結果：spa

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

可已看出，打印的地址值是相同的，既然地址都是相同的，那麼確定是同一個對象。p和p1只是引用而已，他們都指向了一個相同的對象Person(23, "zhang") 。 能夠把這種現象叫作引用的複製。 （關於引用和對象的區分，能夠參考我以前的文章Java中的String爲何是不可變的？ -- String源碼分析 ， 其中有一節講到了引用和對象的區分）。上面代碼執行完成以後， 內存中的情景以下圖所示：.net

Person p = new Person(23, "zhang");  
Person p1 = (Person) p.clone();  
  
System.out.println(p);  
System.out.println(p1);

從打印結果能夠看出，兩個對象的地址是不一樣的，也就是說建立了新的對象， 而不是把原對象的地址賦給了一個新的引用變量：code

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

以上代碼執行完成後， 內存中的情景以下圖所示：對象

 

深拷貝 or 淺拷貝

上面的示例代碼中，Person中有兩個成員變量，分別是name和age， name是String類型， age是int類型。代碼很是簡單，以下所示：blog

public class Person implements Cloneable{  
      
    private String name;
	private int age;
	
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public Person() {
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
      
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return (Person)super.clone();  
    }  
}

因爲age是基本數據類型， 那麼對它的拷貝沒有什麼疑議，直接將一個4字節的整數值拷貝過來就行。可是name是String類型的， 它只是一個引用， 指向一個真正的String對象，那麼對它的拷貝有兩種方式：

（1）直接將源對象中的name的引用值拷貝給新對象的name字段；

（2）根據原Person對象中的name指向的字符串對象建立一個新的相同的字符串對象，將這個新字符串對象的引用賦給新拷貝的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方法執行的是淺拷貝， 在編寫程序時要注意這個細節。

 

覆蓋Object中的clone方法， 實現深拷貝

    如今爲了要在clone對象時進行深拷貝， 那麼就要Clonable接口，覆蓋並實現clone方法，除了調用父類中的clone方法獲得新的對象， 還要將該類中的引用變量也clone出來。若是隻是用Object中默認的clone方法，是淺拷貝的，再次如下面的代碼驗證：

package clone.test;

/**
 * 
 * 代碼修改了一下 
 */
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();
	}
}

class Head {
	public Face face;

	public Head() {
	}

	public Head(Face face) {
		this.face = face;
	}

}

public class CloneTest02 {

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

class Face {
	private String eye;
	private String nose;
	private String mouth;

	/**
    省略set()、get()方法
    */
}

在以上代碼中， 有兩個主要的類， 分別爲Body和Face， 在Body類中， 組合了一個Face對象。當對Body對象進行clone時， 它組合的Face對象只進行淺拷貝。打印結果能夠驗證該結論：

body == body1 : false
body.head == body1.head : true

 

若是要使Body對象在clone時進行深拷貝， 那麼就要在Body的clone方法中，將源對象引用的Head對象也clone一份。

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

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 class CloneTest02 {

	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內的head引用指向了不一樣的Head對象， 也就是說在clone Body對象的同時， 也拷貝了它所引用的Head對象， 進行了深拷貝。

 

真的是深拷貝嗎

由上一節的內容能夠得出以下結論：若是想要深拷貝一個對象， 這個對象必需要實現Cloneable接口，實現clone方法，而且在clone方法內部，把該對象引用的其餘對象也要clone一份 ， 這就要求這個被引用的對象必須也要實現Cloneable接口而且實現clone方法。

 

那麼，按照上面的結論， Body類組合了Head類， 而Head類組合了Face類，要想深拷貝Body類，必須在Body類的clone方法中將Head類也要拷貝一份，可是在拷貝Head類時，默認執行的是淺拷貝，也就是說Head中組合的Face對象並不會被拷貝。驗證代碼以下：（這裏原本只給出Face類的代碼就能夠了， 可是爲了閱讀起來具備連貫性，避免丟失上下文信息， 仍是給出整個程序，整個程序也很是簡短）

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

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

class Face {}

public class CloneTest02 {

	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

那麼，對Body對象來講，算是這算是深拷貝嗎？其實應該算是深拷貝，由於對Body對象內所引用的其餘對象（目前只有Head）都進行了拷貝，也就是說兩個獨立的Body對象內的head引用已經指向了獨立的兩個Head對象。可是，這對於兩個Head對象來講，他們指向了同一個Face對象，這就說明，兩個Body對象仍是有必定的聯繫，並無徹底的獨立。這應該說是一種不完全的深拷貝。

如何進行完全的深拷貝

對於上面的例子來講，怎樣才能保證兩個Body對象徹底獨立呢？只要在拷貝Head對象的時候，也將Face對象拷貝一份就能夠了。這須要讓Face類也實現Cloneable接口，實現clone方法，而且在在Head對象的clone方法中，拷貝它所引用的Face對象。修改的部分代碼以下：

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

class Head implements Cloneable{
	public Face face;

	public Head() {
	}

	public Head(Face face) {
		this.face = face;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		Head newHead =(Head)super.clone();
		newHead.face = (Face)face.clone();
		return newHead;
	}
}

public class CloneTest02 {
	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));  
	}
}

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已經徹底獨立了，他們間接引用的face對象已經被拷貝，也就是引用了獨立的Face對象。內存結構圖以下：

依此類推，若是Face對象還引用了其餘的對象， 好比說Mouth，若是不通過處理，Body對象拷貝以後仍是會經過一級一級的引用，引用到同一個Mouth對象。同理， 若是要讓Body在引用鏈上徹底獨立， 只能顯式的讓Mouth對象也被拷貝。

到此，能夠獲得以下結論：若是在拷貝一個對象時，要想讓這個拷貝的對象和源對象徹底彼此獨立，那麼在引用鏈上的每一級對象都要被顯式的拷貝。因此建立完全的深拷貝是很是麻煩的，尤爲是在引用關係很是複雜的狀況下， 或者在引用鏈的某一級上引用了一個第三方的對象， 而這個對象沒有實現clone方法， 那麼在它以後的全部引用的對象都是被共享的。 舉例來講，若是被Head引用的Face類是第三方庫中的類，而且沒有實現Cloneable接口，那麼在Face以後的全部對象都會被拷貝先後的兩個Body對象共同引用。假設Face對象內部組合了Mouth對象，而且Mouth對象內部組合了Tooth對象， 內存結構以下圖：

 

寫在最後

clone在平時項目的開發中可能用的不是很頻繁，可是區分深拷貝和淺拷貝會讓咱們對java內存結構和運行方式有更深的瞭解。至於完全深拷貝，幾乎是不可能實現的，緣由已經在上一節中進行了說明。深拷貝和完全深拷貝，在建立不可變對象時，可能對程序有着微妙的影響，可能會決定咱們建立的不可變對象是否是真的不可變。clone的一個重要的應用也是用於不可變對象的建立。關於建立不可變對象，我會在後續的文章中進行闡述，敬請期待。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程