原型模式——淺復制與深復制

原型模式涉及一個淺復制和深復制的概念。原型模式可以簡單理解為“復制”，但這個復制不是代碼的復制。對同一個類，我們可以實例化new三次來“復制”，但如果在初始化的時候構造函數的執行很長，多次實例化就顯得效率很低效了。那我們能否只實例化一次，然后“復制”呢？

Test test1 = new Test();
Test test2 = test1;
Test test3 = test1;

這樣寫嗎？注意這是引用的復制，這實際上還是只有test1一個實例，test2、test3只是復制了其引用而已，如果修改了一個對象則會影響到其他的對象。這樣是不符合我們要求的。這就會引出我們Java的clone方法淺復制和深復制了。

我們先來看淺復制是什么。對於要實現克隆（我們后面將淺復制和深復制統稱為克隆），必須實現Cloneable接口，盡管clone方法在Object類里，但我們還是得實現Cloneable接口不然會拋出CloneNotSupportedException錯誤。

定義一個Resume類實現Cloneable接口，並實現Object類中的clone方法。

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Resume implements Cloneable {
    private String name;
    private String sex;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

}

客戶端測試代碼：

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Main {

    /**
     * @param args
     * @throws CloneNotSupportedException 
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        Resume resume1 = new Resume();
        Resume resume2 = (Resume)resume1.clone();
        System.out.println(resume1.hashCode() + " " + resume2.hashCode());
    }

}

我們可以看看輸出結果，resume2是否只是復制了resume1的引用。

看來並不是。並且我們也成功地克隆了一個對象，並不是簡單地復制了引用。我們的Resume類里只有兩個String基本類型，我們來看看如果有其他引用會是什么樣子的。

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Resume implements Cloneable {
    private String name;
    private String sex;
    private Test test = new Test(); 
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Test getTest() {
        return test;
    }

    public void setTest(Test test) {
        this.test = test;
    }

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

}

此時我們增加了一個Test類的引用，其他代碼不變，Test類里什么都沒有。看看客戶端代碼：

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Main {

    /**
     * @param args
     * @throws CloneNotSupportedException 
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        Resume resume1 = new Resume();
        Resume resume2 = (Resume)resume1.clone();
        System.out.println(resume1.hashCode() + " " + resume2.hashCode());
        System.out.println(resume1.getTest().hashCode() + " " + resume2.getTest().hashCode());
    }

}

這個時候對第18行的輸出結果會是什么樣的呢？

我們看到雖然我們對resume1進行了克隆，resume2確實也是新的引用，但由於Resume類中有了對另外一個類的引用，所以resume1和resume2對Test對象的引用還是同一個，這就是淺復制。那么如何做到連同Test對象一起克隆，而不是只復制一個引用呢？這就是深復制的概念。

我們首先對在Resume中被引用的類Test做一點改變，讓它實現Cloneable接口，實現clone方法：

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Test implements Cloneable{
    private String test;

    public String getTest() {
        return test;
    }

    public void setTest(String test) {
        this.test = test;
    }

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

同樣在Resume類中做一點微小的改變：

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Resume implements Cloneable {
    private String name;
    private String sex;
    private Test test = new Test(); 
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Test getTest() {
        return test;
    }

    public void setTest(Test test) {
        this.test = test;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Resume resume = (Resume)super.clone();
        resume.test = (Test)test.clone();
        return resume;
    }

}

客戶端測試代碼不變：

package day_12_prototype;

/**
 * @author turbo
 *
 * 2016年9月17日
 */
public class Main {

    /**
     * @param args
     * @throws CloneNotSupportedException 
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        Resume resume1 = new Resume();
        Resume resume2 = (Resume)resume1.clone();
        System.out.println(resume1.hashCode() + " " + resume2.hashCode());
        System.out.println(resume1.getTest().hashCode() + " " + resume2.getTest().hashCode());
    }

}

輸出結果：

這樣我們就實現了對象的深復制。

說完淺復制與深復制，其實我們也就講完了原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。為什么要通過克隆的方式來創建新的對象，也即是我們在上面提到的，每new一次都需要執行一次構造函數，如果構造函數的執行時間很長，那么多次執行這個初始化操作就實在是太低效了。