Java 深入理解建立型設計模式之原型模式

2022-02-16 19:00:30

1.思考問題

現在有一隻羊 tom，姓名為: tom，年齡為:1，顏色為:白色，請編寫程式建立和 tom羊屬性完全相同的10只羊。

按照傳統的思路來，我們可能會按照下面的方式去寫。

那麼這種寫法的優缺點自然而然就出來了：

優點是比較好理解，簡單易操作。
缺點是在建立新的物件時，總是需要重新獲取原始物件的屬性，如果建立的物件比較複雜時，效率較低。總是需要重新初始化物件，而不是動態地獲得物件執行時的狀態，不夠靈活。
改進的思路分析：Java中Object類是所有類的根類，Object類提供了一個 clone()方法，該方法可以將一個Java物件複製一份，但是需要實現clone的Java類必須要實現一個介面Cloneable，該介面表示該類能夠複製且具有複製的能力 => 原型模式。

2.什麼是原型模式？

原型模式(Prototype模式)是指: 用原型範例指定建立物件的種類，並且通過拷貝這些原型，建立新的物件。
原型模式是一種建立型設計模式，允許一個物件再建立另外一個可客製化的物件，無需知道如何建立的細節。
工作原理是: 通過將一個原型物件傳給那個要發動建立的物件，這個要發動建立的物件通過請求原型物件拷貝它們自己來實施建立，即物件.clone()。

原型模式相關的類圖如下：

3.克隆羊多莉案例程式碼（淺拷貝）

這裡由於我是新建的普通Java專案，並不是maven專案，所以沒法加lombok依賴。那麼這裡的構造器、setter/getter方法顯得這個類的篇幅比較長。。。

package com.szh.prototype.shallowclone;
 
public class Sheep implements Cloneable {
    private String name;
    private Integer age;
    private String color;
    private Sheep friend;
 
    public Sheep(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
 
    public Sheep(String name, Integer age, String color, Sheep friend) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.friend = friend;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
 
    public Sheep getFriend() {
        return friend;
    }
 
    public void setFriend(Sheep friend) {
        this.friend = friend;
    }
 
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", color='" + color + ''' +
                ", friend=" + friend +
                '}';
    }
 
    //克隆該範例，使用預設的clone方法來完成
    @Override
    protected Object clone()  {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

package com.szh.prototype.shallowclone;
 
public class MainTest {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("多莉",5,"黑白相間",new Sheep("喜羊羊",1,"白色"));
 
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();
        Sheep sheep5 = (Sheep) sheep.clone();
 
        System.out.println(sheep + "  sheep.friend.hashCode = " + sheep.getFriend().hashCode());
        System.out.println(sheep2 + "  sheep2.friend.hashCode = " + sheep2.getFriend().hashCode());
        System.out.println(sheep3 + "  sheep3.friend.hashCode = " + sheep3.getFriend().hashCode());
        System.out.println(sheep4 + "  sheep4.friend.hashCode = " + sheep4.getFriend().hashCode());
        System.out.println(sheep5 + "  sheep5.friend.hashCode = " + sheep5.getFriend().hashCode());
    }
}

從上面的執行結果中可以看到，Sheep類中的前三個成員屬性都可以成功的拷貝，但是最後一個friend，它表示羊的朋友（也是Sheep型別，就是參照型別了）。而當我們拷貝完成之後，應該來說都是不一樣的新的物件，但是它們中的friend屬性的hashCode居然是一樣的！！！這裡我們就要來聊一聊深拷貝和淺拷貝了。

淺拷貝：

對於資料型別是基本資料型別的成員變數，淺拷貝會直接進行值傳遞，也就是將該屬性值複製一份給新的物件。
對於資料型別是參照資料型別的成員變數，比如說成員變數是某個陣列、某個類物件等，那麼淺拷貝會進行參照傳遞，也就是隻是將該成員變數的參照值(記憶體地址〉複製一份給新的物件。因為實際上兩個物件的該成員變數都指向同一個範例。在這種情況下，在一個物件中修改該成員變數會影響到另一個物件的該成員變數值。
前面我們克隆羊就是淺拷貝。淺拷貝是使用預設的clone()方法來實現：sheep= (Sheep) super.clone();

深拷貝：

複製物件的所有基本資料型別的成員變數值。
為所有參照資料型別的成員變數申請儲存空間，並複製每個參照資料型別成員變數所參照的物件，直到該物件可達的所有物件。也就是說，物件進行深拷貝要對整個物件(包括物件的參照型別)進行拷貝。
深拷貝實現方式1: 重寫clone方法來實現深拷貝。
深拷貝實現方式2: 通過物件序列化實現深拷貝(推薦)。

4.深拷貝程式碼案例

package com.szh.prototype.deepclone;
 
import java.io.Serializable;
 
public class DeepCloneableTarget implements Serializable, Cloneable {
 
    private static final long serialVersionUID = 1L;
    private String cloneName;
    private String cloneClass;
 
    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }
 
    @Override
    public String toString() {
        return "DeepCloneableTarget{" +
                "cloneName='" + cloneName + ''' +
                ", cloneClass='" + cloneClass + ''' +
                '}';
    }
 
    //因為該類的屬性，都是String , 因此我們這裡使用預設的clone完成即可
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.szh.prototype.deepclone;
 
import java.io.*;
 
public class DeepPrototype implements Serializable, Cloneable {
 
    public String name; //String 屬性
    public DeepCloneableTarget deepCloneableTarget;// 參照型別
 
    public DeepPrototype() {
        super();
    }
 
    @Override
    public String toString() {
        return "DeepPrototype{" +
                "name='" + name + ''' +
                ", deepCloneableTarget=" + deepCloneableTarget +
                '}';
    }
 
    //深拷貝 - 方式 1 使用clone 方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        deep = super.clone();
        DeepPrototype deepPrototype = (DeepPrototype) deep;
        deepPrototype.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
        return deepPrototype;
    }
 
    //深拷貝 - 方式2 通過物件的序列化實現 (推薦)
    public Object deepClone() {
        //建立流物件
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
 
        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
 
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepPrototype copyObj = (DeepPrototype) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //關閉流
            try {
                ois.close();
                bis.close();
                oos.close();
                bos.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}

package com.szh.prototype.deepclone;
 
public class MainTest {
    public static void main(String[] args) throws Exception {
        DeepPrototype prototype = new DeepPrototype();
        prototype.name = "張起靈";
        prototype.deepCloneableTarget = new DeepCloneableTarget("小哥","悶油瓶");
 
        //方式1 完成深拷貝
        DeepPrototype prototype2 = (DeepPrototype) prototype.clone();
        System.out.println("方式1 完成深拷貝");
        System.out.println("prototype.name = " + prototype.name + ", prototype.deepCloneableTarget = " + prototype.deepCloneableTarget);
        System.out.println("prototype.deepCloneableTarget.hashCode = " + prototype.deepCloneableTarget.hashCode());
        System.out.println("-------------------------------------------------------");
        System.out.println("prototype2.name = " + prototype2.name + ", prototype2.deepCloneableTarget = " + prototype2.deepCloneableTarget);
        System.out.println("prototype2.deepCloneableTarget.hashCode = " + prototype2.deepCloneableTarget.hashCode());
        System.out.println("==============================================================================");
 
        //方式2 完成深拷貝
        DeepPrototype prototype3 = (DeepPrototype) prototype.deepClone();
        System.out.println("方式2 完成深拷貝");
        System.out.println("prototype.name = " + prototype.name + ", prototype.deepCloneableTarget = " + prototype.deepCloneableTarget);
        System.out.println("prototype.deepCloneableTarget.hashCode = " + prototype.deepCloneableTarget.hashCode());
        System.out.println("-------------------------------------------------------");
        System.out.println("prototype3.name = " + prototype3.name + ", prototype3.deepCloneableTarget = " + prototype3.deepCloneableTarget);
        System.out.println("prototype3.deepCloneableTarget.hashCode = " + prototype3.deepCloneableTarget.hashCode());
    }
}

5.原型模式總結

建立新的物件比較複雜時，可以利用原型模式簡化物件的建立過程，同時也能夠提高效率。
不用重新初始化物件，而是動態地獲得物件執行時的狀態。
如果原始物件發生變化(增加或者減少屬性)，其它克隆物件的也會發生相應的變化，無需修改程式碼。
在實現深克隆的時候可能需要比較複雜的程式碼。
缺點: 需要為每一個類配備一個克隆方法，這對全新的類來說不是很難，但對已有的類進行改造時，需要修改其原始碼，違背了ocp原則。

到此這篇關於Java 深入理解建立型設計模式之原型模式的文章就介紹到這了,更多相關Java 原型模式內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！