Java中對象的創建

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

1 使用new操作符創建一個對象

2 使用clone方法複製一個對象

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

複製對象 or 複製引用

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

[java] view plain copy

print?

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

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

        System.out.println(p);
        System.out.println(p1);

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

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

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

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

[java] view plain copy

print?

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

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

        System.out.println(p);
        System.out.println(p1);

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

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

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

深拷貝 or 淺拷貝

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

[java] view plain copy

print?

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

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字段。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示：

下面通過代碼進行驗證。如果兩個Person對象的name的地址值相同，說明兩個對象的name都指向同一個String對象，也就是淺拷貝，而如果兩個對象的name的地址值不同，那麼就說明指向不同的String對象，也就是在拷貝Person對象的時候，同時拷貝了name引用的String對象，也就是深拷貝。驗證代碼如下：

[java] view plain copy

print?

Person p = new Person(23, “zhang”);
Person p1 = (Person) p.clone();
String result = p.getName() == p1.getName()
? ”clone是淺拷貝的” : “clone是深拷貝的”;
System.out.println(result);

       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方法，是淺拷貝的，再次以下面的代碼驗證：

[java] view plain copy

print?

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

   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一份。

[java] view plain copy

print?

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

    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內的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 copy

print?

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

   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

內存結構圖如下圖所示：

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

如何進行徹底的深拷貝

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

[java] view plain copy

print?

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

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

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

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

寫在最後

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

站內首發文章

HankingHu 博客專家

發佈了186 篇原創文章 · 獲贊 675 · 訪問量 64萬+

他的留言板關注

Java clone方法深拷貝淺拷貝完全解析

Java中對象的創建

複製對象 or 複製引用

深拷貝 or 淺拷貝

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

真的是深拷貝嗎

如何進行徹底的深拷貝

寫在最後

公司新來一個幹練小夥，把 MyBatis 替換成 MyBatis-Plus，上線後哭暈在廁所。。。

支持非IE瀏覽器真的那麼難嗎？

爲啥就那麼痛恨IE？

2024 開源數據工程生態系統全景圖

Brian Sun：回覆“爲啥就那麼痛恨IE？”

【筆記】動手學深度學習-前言

體驗下，大廠在使用功能的API網關！

見鬼了！我家的 WiFi 只有下雨天才能正常使用...

短視頻文案提取原來如此簡單

oa系統集成及案例樣式

java多線程相關問題彙總

Android卡頓檢測及優化

Android松耦合監聽前後臺切換框架

Room Database完全解析

圖解Android中的Binder機制

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Java clone方法深拷貝淺拷貝完全解析

Java中對象的創建

複製對象 or 複製引用

深拷貝 or 淺拷貝

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

真的是深拷貝嗎

如何進行徹底的深拷貝

寫在最後

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