Java不僅吸收了C++語言的各種優點,還摒棄了C++裡難以理解的多繼承、指標等概念。那麼大家知道Java中的clone方法是什麼呢?下面一起來看看!
Java中物件的建立
clone顧名思義就是複製, 在Java語言中, clone方法被物件呼叫,所以會複製物件。所謂的複製物件,首先要分配一個和源物件同樣大小的空間,在這個空間中建立一個新的物件。那麼在java語言中,有幾種方式可以建立物件呢?
1 使用new操作符建立一個物件
2 使用clone方法複製一個物件
那麼這兩種方式有什麼相同和不同呢? new操作符的本意是分配記憶體。程式執行到new操作符時, 首先去看new操作符後面的型別,因為知道了型別,才能知道要分配多大的記憶體空間。分配完記憶體之後,再呼叫建構函式,填充物件的各個域,這一步叫做物件的初始化,構造方法返回後,一個物件建立完畢,可以把他的引用(地址)釋出到外部,在外部就可以使用這個引用操縱這個物件。而clone在第一步是和new相似的, 都是分配記憶體,呼叫clone方法時,分配的記憶體和源物件(即呼叫clone方法的物件)相同,然後再使用原物件中對應的各個域,填充新物件的域, 填充完成之後,clone方法返回,一個新的相同的物件被建立,同樣可以把這個新物件的引用釋出到外部。
複製物件 or 複製引用
在Java中,以下類似的程式碼非常常見:
[java] view plain copyPerson p = new Person(23, "zhang");
Person p1 = p;
tln(p);
tln(p1);
當Person p1 = p;執行之後, 是建立了一個新的物件嗎? 首先看列印結果:
on@2f9ee1ac
on@2f9ee1ac
可已看出,列印的地址值是相同的,既然地址都是相同的,那麼肯定是同一個物件。p和p1只是引用而已,他們都指向了一個相同的物件Person(23, "zhang") 。 可以把這種現象叫做引用的複製。 (關於引用和物件的區分,可以參考我之前的文章Java中的String為什麼是不可變的? -- String原始碼分析 , 其中有一節講到了引用和物件的區分)。上面程式碼執行完成之後, 記憶體中的情景如下圖所示:
而下面的程式碼是真真正正的克隆了一個物件。
[java] view plain copyPerson p = new Person(23, "zhang");
Person p1 = (Person) e();
tln(p);
tln(p1);
從列印結果可以看出,兩個物件的地址是不同的,也就是說建立了新的物件, 而不是把原物件的地址賦給了一個新的引用變數:
on@2f9ee1ac
on@67f1fba0
以上程式碼執行完成後, 記憶體中的情景如下圖所示:
深拷貝 or 淺拷貝
上面的示例程式碼中,Person中有兩個成員變數,分別是name和age, name是String型別, age是int型別。程式碼非常簡單,如下所示:
[java] view plain copypublic class Person implements Cloneable{
private int age ;
private String name;
public Person(int age, String name) {
= age;
= name;
}
public Person() {}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return (Person)e();
}
}
由於age是基本資料型別, 那麼對它的拷貝沒有什麼疑議,直接將一個4位元組的整數值拷貝過來就行。但是name是String型別的, 它只是一個引用, 指向一個真正的String物件,那麼對它的拷貝有兩種方式: 直接將源物件中的name的引用值拷貝給新物件的name欄位, 或者是根據原Person物件中的name指向的字串物件建立一個新的相同的字串物件,將這個新字串物件的引用賦給新拷貝的Person物件的name欄位。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示:
下面通過程式碼進行驗證。如果兩個Person物件的name的地址值相同, 說明兩個物件的name都指向同一個String物件, 也就是淺拷貝, 而如果兩個物件的name的地址值不同, 那麼就說明指向不同的`String物件, 也就是在拷貝Person物件的時候, 同時拷貝了name引用的String物件, 也就是深拷貝。驗證程式碼如下:
[java] view plain copyPerson p = new Person(23, "zhang");
Person p1 = (Person) e();
String result = ame() == ame()
? "clone是淺拷貝的" : "clone是深拷貝的";
tln(result);
列印結果為:
clone是淺拷貝的
所以,clone方法執行的是淺拷貝, 在編寫程式時要注意這個細節。
覆蓋Object中的clone方法, 實現深拷貝
現在為了要在clone物件時進行深拷貝, 那麼就要Clonable介面,覆蓋並實現clone方法,除了呼叫父類中的clone方法得到新的物件, 還要將該類中的引用變數也clone出來。如果只是用Object中預設的clone方法,是淺拷貝的,再次以下面的程式碼驗證:
[java] view plain copystatic class Body implements Cloneable{
public Head head;
public Body() {}
public Body(Head head) { = head;}
@Override
protected Object clone() throws CloneNotSupportedException {
return e();
}
}
static class Head /*implements Cloneable*/{
public Face face;
public Head() {}
public Head(Face face){ = face;}
}
public static void main(String[] args) throws CloneNotSupportedException {
Body body = new Body(new Head());
Body body1 = (Body) e();
tln("body == body1 : " + (body == body1) );
tln(" == : " + ( == ));
}
在以上程式碼中, 有兩個主要的類, 分別為Body和Face, 在Body類中, 組合了一個Face物件。當對Body物件進行clone時, 它組合的Face物件只進行淺拷貝。列印結果可以驗證該結論:
body == body1 : false
== : true
如果要使Body物件在clone時進行深拷貝, 那麼就要在Body的clone方法中,將源物件引用的Head物件也clone一份。
[java] view plain copystatic class Body implements Cloneable{
public Head head;
public Body() {}
public Body(Head head) { = head;}
@Override
protected Object clone() throws CloneNotSupportedException {
Body newBody = (Body) e();
= (Head) e();
return newBody;
}
}
static class Head implements Cloneable{
public Face face;
public Head() {}
public Head(Face face){ = face;}
@Override
protected Object clone() throws CloneNotSupportedException {
return e();
}
}
public static void main(String[] args) throws CloneNotSupportedException {
Body body = new Body(new Head());
Body body1 = (Body) e();
tln("body == body1 : " + (body == body1) );
tln(" == : " + ( == ));
}
列印結果為:
body == body1 : false
== : 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類的程式碼就可以了, 但是為了閱讀起來具有連貫性,避免丟失上下文資訊, 還是給出整個程式,整個程式也非常簡短)
[java] view plain copystatic class Body implements Cloneable{
public Head head;
public Body() {}
public Body(Head head) { = head;}
@Override
protected Object clone() throws CloneNotSupportedException {
Body newBody = (Body) e();
= (Head) e();
return newBody;
}
}
static class Head implements Cloneable{
public Face face;
public Head() {}
public Head(Face face){ = face;}
@Override
protected Object clone() throws CloneNotSupportedException {
return e();
}
}
static class Face{}
public static void main(String[] args) throws CloneNotSupportedException {
Body body = new Body(new Head(new Face()));
Body body1 = (Body) e();
tln("body == body1 : " + (body == body1) );
tln(" == : " + ( == ));
tln(" == : " + ( == ));
}
列印結果為:
body == body1 : false
== : false
== : true
記憶體結構圖如下圖所示:
那麼,對Body物件來說,算是這算是深拷貝嗎?其實應該算是深拷貝,因為對Body物件內所引用的其他物件(目前只有Head)都進行了拷貝,也就是說兩個獨立的Body物件內的head引用已經指向了獨立的兩個Head物件。但是,這對於兩個Head物件來說,他們指向了同一個Face物件,這就說明,兩個Body物件還是有一定的聯絡,並沒有完全的獨立。這應該說是一種不徹底的深拷貝。
如何進行徹底的深拷貝
對於上面的例子來說,怎樣才能保證兩個Body物件完全獨立呢?只要在拷貝Head物件的時候,也將Face物件拷貝一份就可以了。這需要讓Face類也實現Cloneable介面,實現clone方法,並且在在Head物件的clone方法中,拷貝它所引用的Face物件。修改的部分程式碼如下:
[java] view plain copystatic class Head implements Cloneable{
public Face face;
public Head() {}
public Head(Face face){ = face;}
@Override
protected Object clone() throws CloneNotSupportedException {
//return e();
Head newHead = (Head) e();
= (Face) e();
return newHead;
}
}
static class Face implements Cloneable{
@Override
protected Object clone() throws CloneNotSupportedException {
return e();
}
}
再次執行上面的示例,得到的執行結果如下:
body == body1 : false
== : false
== : false