設計模式之--原型模式

1.原型模式定義

原型模式非常簡單，定義如下：

用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象

2.通用類圖

原型模式的核心是實現Cloneable接口，此接口為JDK提供的一個標識接口，只有實現了此接口的類才能被拷貝。
原型模式的通用類圖如下；

3.通用原型實現代碼

原型類：

public class ConcretePrototype implements Cloneable {

    private int id;

    private String name;

    public ConcretePrototype() {
        System.out.println("ConcretePrototype construct.");
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        ConcretePrototype concretePrototype = null;
        try {
            concretePrototype = (ConcretePrototype) super.clone();
        } catch (Exception e) {

        }
        return concretePrototype;
    }

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

Client測試代碼：

public class Client {

    public static void main(String[] args) throws Exception {
        ConcretePrototype concretePrototype = new ConcretePrototype();
        concretePrototype.setId(123);
        concretePrototype.setName("test");

        ConcretePrototype cloneType = (ConcretePrototype) concretePrototype.clone();
        cloneType.setId(111);
        cloneType.setName("test111");
        System.out.println(concretePrototype);
        System.out.println(cloneType);
    }
}

輸出結果如下：

ConcretePrototype construct.
ConcretePrototype{id=123, name='test'}
ConcretePrototype{id=111, name='test111'}

通過輸出結果可以看出，通過clone方法拷貝了一個新的對象。

4.原型模式的優點

1.性能優良
原型模式是在內存中二進制流的拷貝，要比直接new一個對象快的多

2.通過3中的輸出結果來看，在clone對象的時候構造函數不會執行，這對於一些需要在構造函數中做一些初始化的類來說可能稱為約束

5.需要注意的點

在原型模式拷貝的時候需要注意可變引用類型的屬性，下面通過一個例子來說明此問題：
拷貝對象：

public class DeepClone implements Cloneable{

    private Map<String, Object> map = new HashMap<>();

    public void addPair(String key, String value){
        map.put(key, value);
    }

    public Map<String , Object> getMap(){
        return map;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        DeepClone  deepClone = null;
        try {
            deepClone = (DeepClone) super.clone();
        } catch (Exception e) {

        }
        return deepClone;
    }
}

Client類

public class Client {

    public static void main(String[] args) throws Exception {
        DeepClone deepClone = new DeepClone();
        deepClone.addPair("key1", "value1");

        DeepClone clone = (DeepClone) deepClone.clone();
        clone.addPair("key2", "value2");
        System.out.println(deepClone.getMap());

    }


}

輸出結果如下：

{key1=value1, key2=value2}

在使用clone方法拷貝對象的時候引用類型的屬性不會繼續做拷貝，而是多個拷貝對象使用同一個屬性，這種被稱為淺拷貝。
下面對clone方法重寫完成深拷貝：

@Override
protected Object clone() throws CloneNotSupportedException {
    DeepClone  deepClone = null;
    try {
        deepClone = (DeepClone) super.clone();
        Map<String, Object> cloneMap = new HashMap<>();
        cloneMap.putAll(this.map);

        deepClone.map = cloneMap;
    } catch (Exception e) {

    }
    return deepClone;
}

重新執行client輸出結果為：

{key1=value1}