2. 程式人生 > >淺談Java的標識介面－cloneable

淺談Java的標識介面－cloneable

阿新 • • 發佈：2019-01-26

為什麼對物件進行克隆

談到了物件的克隆，就不得不說為什麼要對物件進行克隆？Java中所有的物件都是儲存在堆中，而堆是供全域性共享的。也就是說，如果同一個Java程式的不同方法，只要能拿到某個物件的引用，引用者就可以隨意的修改物件的內部資料（前提是這個物件的內部資料通過get/set方法曝露出來）。有的時候，我們編寫的程式碼想讓呼叫者只獲得該物件的一個拷貝（也就是一個內容完全相同的物件，但是在記憶體中存在兩個這樣的物件），有什麼辦法可以做到呢？當然是克隆咯。

clone()函式和cloneable介面
先來看一下他們在文件中的描述：
Cloneable:
這裡寫圖片描述

Clone():
這裡寫圖片描述

通過上述的描述，我們可以看出，要讓一個物件進行克隆，其實就是兩個步驟：

  1. 讓該類實現java.lang.Cloneable介面；
  2. 重寫（override）Object類的clone()方法。

例項

class User implements Cloneable
{
    int id;
    int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int
 
 getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public User(int id,int age){
        this.id = id;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
      return super.clone();
    }

   //一定要重寫，否則利用equals（）會出錯
 

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        if (id != user.id) return false;

        return true;
    }

   //一定要重寫，否則利用equals（）會出錯.
    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        return result;
    }
}

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user1 = new User(1,12);
        User user2 = user1;
        User user3 = (User) user1.clone();

        System.out.println(user1==user2);//true
        System.out.println(user1.equals(user2));//true
        System.out.println(user1==user3);//false
        System.out.println(user1.equals(user3));//true
    }
}

注:剛開始的時候只是重寫了clone(),致使System.out.println(user1.equals(user3));一直為false具體原因請參考淺談java的==,equals(),hashcode()

但是事實真的就這樣簡單了，請看下面的程式碼：

class Administrator implements Cloneable
{
    private User user;
    private boolean editable;

    public Administrator(User user,boolean editable){
        this.user = user;
        this.editable = editable;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public boolean isEditable() {
        return editable;
    }

    public void setEditable(boolean editable) {
        this.editable = editable;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Administrator that = (Administrator) o;

        if (editable != that.editable) return false;
        if (user != null ? !user.equals(that.user) : that.user != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = user != null ? user.hashCode() : 0;
        result = 31 * result + (editable ? 1 : 0);
        return result;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Administrator a1 = new Administrator(new User(1,12),true);
        Administrator a2 = a1;
        Administrator a3 = (Administrator) a1.clone();

        System.out.println(a1==a2);//true
        System.out.println(a1.equals(a2));//true
        System.out.println(a1==a3);//false
        System.out.println(a1.equals(a3));//false
        System.out.println(a1.getUser()==a3.getUser());//true,不可思議了吧！！！
        System.out.println(a1.getUser().equals(a3.getUser()));//true
    }
}

出問題了吧!!!這裡我們就可以引入兩個專業的術語：淺克隆（shallow clone）和深克隆（deep clone）。

所謂的淺克隆，顧名思義就是很表面的很表層的克隆，如果我們要克隆Administrator物件，只克隆他自身以及他包含的所有物件的引用地址。
而深克隆，就是非淺克隆。克隆除自身以外所有的物件，包括自身所包含的所有物件例項。至於深克隆的層次，由具體的需求決定，也有“N層克隆”一說。
但是，所有的基本（primitive）型別資料，無論是淺克隆還是深克隆，都會進行原值克隆。畢竟他們都不是物件，不是儲存在堆中。注意：基本資料型別並不包括他們對應的包裝類。

如果我們想讓物件進行深度克隆，我們可以這樣修改Administrator類。


    @Override
    protected Object clone() throws CloneNotSupportedException {
        Administrator a = (Administrator) super.clone();
        //在方法內部呼叫持有物件的clone()方法；
        a.user = (User) a.user.clone();
        return a;
    }

所以實現深度克隆的步驟如下：

  1. 讓該類實現java.lang.Cloneable介面；
  2. 確認持有的物件是否實現java.lang.Cloneable介面並提供clone()方法；
  3. 重寫（override）Object類的clone()方法，並且在方法內部呼叫持有物件的clone()方法；
  4. ……
  5. 多麻煩啊，調來調去的，如果有N多個持有的物件，那就要寫N多的方法，突然改變了類的結構，還要重新修改clone()方法。

首先編寫一個工具類：

public abstract class BeanUtil {
    @SuppressWarnings("unchecked")
    public static Administrator cloneTo(Administrator src){
        ByteArrayOutputStream memoryBuffer = new ByteArrayOutputStream();
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        Administrator dist = null;
        try {
            out = new ObjectOutputStream(memoryBuffer);
            out.writeObject(src);
            out.flush();
            in = new ObjectInputStream(new ByteArrayInputStream(memoryBuffer.toByteArray()));
            dist = (Administrator) in.readObject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (out != null)
                try {
                    out.close();
                    out = null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            if (in != null)
                try {
                    in.close();
                    in = null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
        }
        return dist;
    }
}

使User,Administrator實現介面Serializable

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Administrator a1 = new Administrator(new User(1,12),true);
        Administrator a3 = BeanUtil.cloneTo(a1);

        System.out.println(a1==a3);//false
        System.out.println(a1.equals(a3));//true
        System.out.println(a1.getUser()==a3.getUser());//false
        System.out.println(a1.getUser().equals(a3.getUser()));//true
    }
}

好了，無論你的物件有多麼的複雜，只要這些物件都能夠實現java.lang.Serializable介面，就可以進行克隆，而且這種克隆的機制是JVM完成的，不需要修改實體類的程式碼，方便多了。

為什麼這麼簡單就可以實現物件的克隆呢？java.lang.Serializable介面又是幹嘛用的呢？

**把物件寫到流裡的過程是序列化過程（Serialization），而把物件從流中讀出來的過程則叫做反序列化過程（Deserialization）。(上面的BeanUtil就是實現序列化反序列化的工具類．)
應當指出的是，寫在流裡的是物件的一個拷貝，而原物件仍然存在於JVM裡面。
在Java語言裡深複製一個物件，常常可以先使物件實現Serializable介面，然後把物件（實際上只是物件的一個拷貝）寫到一個流裡，再從流裡讀出來，便可以重建物件。
這樣做的前提是物件以及物件內部所有引用到的物件都是可序列化的，否則，就需要仔細考察那些不可序列化的物件可否設成transient，從而將其排除在複製過程之外。**

相關推薦

淺談Java的標識介面－cloneable

為什麼對物件進行克隆 談到了物件的克隆，就不得不說為什麼要對物件進行克隆？Java中所有的物件都是儲存在堆中，而堆是供全域性共享的。也就是說，如果同一個Java程式的不同方法，只要能拿到某個物件的引用，引用者就可以隨意的修改物件的內部資料（前提是這個物件

淺談Java Future介面

Java專案程式設計中，為了充分利用計算機CPU資源，一般開啟多個執行緒來執行非同步任務。但不管是繼承Thread類還是實現Runnable介面，都無法獲取任務執行的結果。JDK 5中引入了Callable和Future，通過它們執行非同步任務可以獲取執行結果。FutureTask分析JDK 5中獲取任務執行

淺談JAVA驗證碼~

puts oid blog 方式 log 需求 .html index.jsp script 這兩天在幫同學做個項目，項目中需要做個驗證碼，說實話那麽多年竟然沒註意過這東西，原理很簡單，貼出來給大家做個參考。 1、簡單介紹 一般稍微有些經驗的程序員都不會再自己寫原生驗證碼生

淺談Java中的hashCode方法

implement state ask get() 存在 rsa key 沖突 如何 哈希表這個數據結構想必大多數人都不陌生，而且在很多地方都會利用到hash表來提高查找效率。在Java的Object類中有一個方法: public native int hashCode(

淺談java內存分配和回收策略

內存空間 高效率 cde map details 閾值 老年代 total 關於 一、導論 　　java技術體系中所提到的內存自動化管理歸根結底就是內存的分配與回收兩個問題，之前已經和大家談過java回收的相關知識，今天來和大家聊聊java對象的在內存中的分配。通俗的講，對

淺談Java集合框架

順序 eem map pre 叠代器 static 支持 print ted 集合框架最大的作用就是維護一組類型同樣的對象。僅僅是不同的類有不同的行為和性能。通常關註下面這些行為： 是否能存放反復的元素遍歷的順序是如何的是否支持多線程 以下首先介紹集合的經常使用，隨

淺談Java的學習

override web ring 只知道 網頁標簽 insert語句 知識 reg 模型 Java就是用來做項目的！Java的主要應用領域就是企業級的項目開發！要想從事企業級的項目開發，你必須掌握如下要點： 1、掌握項目開發的基本步驟2、具備極強的面向對象的分析與設計技巧

淺談java中內置的觀察者模式與動態代理的實現

所有 代理 notify play ani effect 一個 indicate protected 一.關於觀察者模式 1.將觀察者與被觀察者分離開來，當被觀察者發生變化時，將通知所有觀察者，觀察者會根據這些變化做出對應的處理。 2.jdk裏已經提供對應的Observer

淺談Java中的深拷貝和淺拷貝

detail tle pac err @override 復制對象 deep har 間接 　　淺談Java中的深拷貝和淺拷貝（轉載） 原文鏈接： http://blog.csdn.net/tounaobun/article/details/8491392 假如說你想復制一

201671010116. 2016-2017-3《Java程序設計》淺談Java

虛擬 專業 ble ise 解釋執行 long [] 程序編譯 orm 1.Java的工作方式：java把程序編譯為字節碼，字節碼可以在提供了Java虛擬機的任何系統上被解釋執行 。 源文件：文件名.java→字節碼文件：文件名.class→java虛擬機支持程序運行 2.

淺談java異常[Exception]

你在 這也 一點 io操作 www. 新手 公司 manager other 淺談java異常[Exception] 一． 異常的定義 在《java編程思想》中這樣定義 異常：阻止當前方法或作用域繼續執行的問題。雖然java中有異常處理機制，但是要明確一點，決不應該

淺談JAVA中“增強”類的某個方法的幾個中方法！

exc 目標 byte 相同 nbsp 優點 method value oca 一、繼承　使用場景：能夠控制這個類的構造的時候，才可以使用繼承。　　優點：簡單容易使用，　缺點：耦合性大大的增強，不利於後期的維護，所以對於繼承這種方法，謹慎使用。 代碼實現：二、裝飾者模式　

淺談Java SE、Java EE、Java ME三者的區別

網絡 orien service 離線 web 手機 規範 嵌入 ice 1. Java SE（Java Platform，Standard Edition）。Java SE 以前稱為 J2SE。它允許開發和部署在桌面、服務器、嵌入式環境和實時環境中使用的 Java 應用程

淺談Web緩存－緩存的實現過程詳解

根據 直觀 pre -i sha 轉載 align 緩存 請求轉發 在前端開發中，性能一直都是被大家所重視的一點，然而判斷一個網站的性能最直觀的就是看網頁打開的速度。其中提高網頁反應速度的一個方式就是使用緩存。一個優秀的緩存策略可以縮短網頁請求資源的距離，減少延遲，並且

淺談JAVA中字符串常量的儲存位置

數據 每一個 [] jit 返回 inf post 符號 boolean 在講述這些之前我們需要一些預備知識： Java的內存結構我們可以通過兩個方面去看待它。 一、從抽象的JVM的角度去看。相關定義請參考JVM規範：Chapter 2. The Structure o

淺談java中的"=="和eqals區別

short copy 覆寫 main 否則 變量 程序 bar gif 在初學Java時，可能會經常碰到下面的代碼： 1 String str1 = new String("hello"); 2 String str2 = new String("hello");

Java基礎8-淺談java程序的運行機制與JVM運行

style 窗口 exe 了解 體感 語法 我們 nbsp .exe 一、java程序的運行機制 Java開發的整個生命周期，可以概括為兩個階段：編譯階段和運行階段。 1.編譯階段 ①程序員編寫一個符合java語法的xx.java的源文件。 ②使用javac.exe命令對以

淺談java放射機制

bject bootstrap pan voc get set class文件 獲得 訪問 java反射機制概念: 用途:JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性；這種動態獲取

淺談java淺拷貝和深拷貝

原來 變量 基本數據 的區別 引用數據類型 復制 值傳遞 ec2 深拷貝和淺拷貝 前言:深拷貝和淺拷貝的區別是什麽？ 淺拷貝：被復制的對象的所有變量都含有原來對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之， 淺拷貝僅僅復制所考慮的對象，而不復制它所引用的對

最近在研究多線程，淺談JAVA中多線程的幾種實現方式

進行 數據 使用 導致 效率問題 多線程 方法 sta img 多線程的實現方式： 　　個人認為，要說多線程的實現方式，萬變不離其宗，最基本的就是兩種1.繼承Thread類；2.實現runnable接口，本質上來說就是用來啟動線程執行任務的過程，具體來說的話，通過這