java設計模式–原型模式詳解

Posted on 2021-07-19 by WalkonNet

引例

問題：

現在有一隻羊（包含屬性：名字Dolly、年齡2），需要克隆10隻屬性完全相同的羊。

一般解法：

定義Sheep類表示羊，包括構造器、getter()和toString()。

public class Sheep {
    private String name;
    private int age;
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在客戶端實例化多利，然後再根據多利的屬性去實例化10隻羊。

public class Client {
    public static void main(String[] args) {
        Sheep sheepDolly=new Sheep("Dolly",2);
        Sheep sheep1 = new Sheep(sheepDolly.getName(), sheepDolly.getAge());
        Sheep sheep2 = new Sheep(sheepDolly.getName(), sheepDolly.getAge());
        Sheep sheep3 = new Sheep(sheepDolly.getName(), sheepDolly.getAge());
        //....
        System.out.println(sheep1+",hashCode:"+sheep1.hashCode());
        System.out.println(sheep2+",hashCode:"+sheep2.hashCode());
        System.out.println(sheep3+",hashCode:"+sheep3.hashCode());
        //...
    }
}

運行結果

在這裡插入圖片描述

優缺點：

這種方法是我們首先很容易就能想到的，也是絕大多數人的第一做法。

但缺點也很明顯，每次創建新對象時需要獲取原始對象的屬性，對象復雜時效率很低；此外不能動態獲得對象運行時的狀態，若類增減屬性需要改動代碼。

下面我們看下原型模式的解法。

原型模式

原型模式(Prototype Pattern)是一種創建型設計模式，允許一個對象再創建另外一個可定制的對象，無需知道如何創建的細節。即用原型實例指定創建對象的種類，並且通過拷貝這些原型，創建新的對象。

工作原理：將原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。即用基類Object的clone()方法或序列化。

UML類圖：

在這裡插入圖片描述

Prototype：原型類，聲明一個克隆自己的接口
ConcretePrototype: 具體的原型類, 實現一個克隆自己的操作
Client: 客戶端讓一個原型對象克隆自己，從而創建一個新的對象

原型模式又可分為淺拷貝和深拷貝，區別在於對引用數據類型的成員變量的拷貝，~~小朋友你是否有很多問號？~~ 不急，看完這兩種方法實現你就懂瞭。

淺拷貝

在原先Sheep類基礎上實現Cloneable接口，重寫clone方法。

public class Sheep implements Cloneable{
    private String name;
    private int age;
    @Override
    protected Object clone()  {//克隆該實例，使用默認的clone方法來完成
        Sheep sheep = null;
        try {
            sheep = (Sheep)super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

客戶端調用

public class Client {
    public static void main(String[] args) {
        Sheep sheepDolly=new Sheep("Dolly",2);
        Sheep sheep1 = (Sheep)sheepDolly.clone();
        Sheep sheep2 = (Sheep)sheepDolly.clone();
        Sheep sheep3 = (Sheep)sheepDolly.clone();
        //....
        System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
        System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
        System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
        //...
    }
}

運行結果

在這裡插入圖片描述

至此，原型模式的淺拷貝也成功克隆瞭三個對象，但是看進度條發現並不簡單。

現在小羊有瞭一個朋友小牛，Sheep類添加瞭一個引用屬性Cow，我們同樣再克隆一遍。

Sheep類

public class Sheep implements Cloneable{
    private String name;
    private int age;
    public Cow friend;//新朋友Cow對象，其餘不變
    @Override
    protected Object clone()  {
        Sheep sheep = null;
        try {
            sheep = (Sheep)super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

新添的Cow類

public class Cow {
    private String name;
    private int age;
    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Cow{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

客戶端調用克隆

public class Client {
    public static void main(String[] args) {
        Sheep sheepDolly=new Sheep("Dolly",2);
        sheepDolly.friend=new Cow("Tom",1); //並實例化朋友
        Sheep sheep1 = (Sheep)sheepDolly.clone();
        Sheep sheep2 = (Sheep)sheepDolly.clone();
        Sheep sheep3 = (Sheep)sheepDolly.clone();
        //....
        System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
        System.out.println("sheep1.friend:"+sheep1.friend+",hashCode:" + sheep1.friend.hashCode()+'\n');
        System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
        System.out.println("sheep2.friend:"+sheep2.friend+",hashCode:" + sheep2.friend.hashCode()+'\n');
        System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
        System.out.println("sheep3.friend:"+sheep3.friend+",hashCode:" + sheep3.friend.hashCode()+'\n');
        //...
    }
}

運行結果

在這裡插入圖片描述

通過運行結果發現，淺拷貝通過Object的clone()成功克隆實例化瞭三個新對象，但是並沒有克隆實例化對象中的引用屬性，也就是沒有克隆friend對象（~~禁止套娃~~ ），三個新克隆對象的friend還是指向原克隆前的friend，即同一個對象。

這樣的話，他們四個的friend是引用同一個，若一個對象修改瞭friend屬性，勢必會影響其他三個對象的該成員變量值。

小結：

淺拷貝是使用默認的 clone()方法來實現
基本數據類型的成員變量，淺拷貝會直接進行值傳遞（復制屬性值給新對象）。
引用數據類型的成員變量，淺拷貝會進行引用傳遞（復制引用值(內存地址)給新對象）。

深拷貝

方法一：

機靈的人兒看出，再clone一遍cow不就好瞭，但是手動遞歸下去不推薦。

1.Cow類也實現Cloneable接口

public class Cow implements Cloneable{
    private String name;
    private int age;
    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //無引用類型，直接clone即可
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); //直接拋出瞭，沒用try-catch
    }
    @Override
    public String toString() {
        return "Cow{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Sheep類的clone再添加調用cow的clone

public class Sheep implements Cloneable{
    private String name;
    private int age;
    public Cow friend;//新朋友Cow對象，其餘不變
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //完成對基本數據類型(屬性)和String的克隆
        deep = super.clone();
        //對引用類型的屬性，進行再次clone
        Sheep sheep = (Sheep)deep;
        sheep.friend  = (Cow)friend.clone();
        return sheep;
    }
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

客戶端調用

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheepDolly=new Sheep("Dolly",2);
        sheepDolly.friend=new Cow("Tom",1); //並實例化朋友
        Sheep sheep1 = (Sheep)sheepDolly.clone();
        Sheep sheep2 = (Sheep)sheepDolly.clone();
        Sheep sheep3 = (Sheep)sheepDolly.clone();
        //....
        System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
        System.out.println("sheep1.friend:"+sheep1.friend+",hashCode:" + sheep1.friend.hashCode()+'\n');
        System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
        System.out.println("sheep2.friend:"+sheep2.friend+",hashCode:" + sheep2.friend.hashCode()+'\n');
        System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
        System.out.println("sheep3.friend:"+sheep3.friend+",hashCode:" + sheep3.friend.hashCode()+'\n');
        //...
    }
}

運行結果

在這裡插入圖片描述

方法二：

通過對象序列化實現深拷貝(推薦)

1.Cow類實現序列化接口，不必實現Cloneable接口瞭

public class Cow implements Serializable {
    private String name;
    private int age;
    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Cow{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.在Sheep類實現序列化接口

public class Sheep implements Serializable { //實現序列化接口
    private String name;
    private int age;
    public Cow friend;

    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    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);
            Sheep sheep = (Sheep) ois.readObject();
            return sheep;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //關閉流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}

3.客戶端調用

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheepDolly=new Sheep("Dolly",2);
        sheepDolly.friend=new Cow("Tom",1); //並實例化朋友
        Sheep sheep1 = (Sheep)sheepDolly.deepClone();
        Sheep sheep2 = (Sheep)sheepDolly.deepClone();
        Sheep sheep3 = (Sheep)sheepDolly.deepClone();
        //....
        System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
        System.out.println("sheep1.friend:"+sheep1.friend+",hashCode:" + sheep1.friend.hashCode()+'\n');
        System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
        System.out.println("sheep2.friend:"+sheep2.friend+",hashCode:" + sheep2.friend.hashCode()+'\n');
        System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
        System.out.println("sheep3.friend:"+sheep3.friend+",hashCode:" + sheep3.friend.hashCode()+'\n');
        //...
    }
}

運行結果

在這裡插入圖片描述

原型模式總結：

創建新的對象比較復雜時，可以利用原型模式簡化對象的創建過程，同時也能夠提高效率
可以不用重新初始化對象，動態地獲得對象運行時的狀態。
如果原始對象發生變化(增加或者減少屬性)，其它克隆對象的也會發生相應的變化，無需修改代碼
若成員變量無引用類型，淺拷貝clone即可；若引用類型的成員變量很少，可考慮遞歸實現clone，否則推薦序列化。

總結

本篇文章就到這裡瞭，希望能給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

java設計模式–原型模式詳解

目錄

引例

原型模式

淺拷貝

在原先Sheep類基礎上實現Cloneable接口，重寫clone方法。

客戶端調用

Sheep類

新添的Cow類

客戶端調用克隆

深拷貝

1.Cow類也實現Cloneable接口

Sheep類的clone再添加調用cow的clone

客戶端調用

1.Cow類實現序列化接口，不必實現Cloneable接口瞭

2.在Sheep類實現序列化接口

3.客戶端調用

總結

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

引例

原型模式

淺拷貝

在原先Sheep類基礎上實現Cloneable接口，重寫clone方法。

客戶端調用

Sheep類

新添的Cow類

客戶端調用克隆

深拷貝

1.Cow類也實現Cloneable接口

Sheep類的clone再添加調用cow的clone

客戶端調用

1.Cow類實現序列化接口，不必實現Cloneable接口瞭

2.在Sheep類實現序列化接口

3.客戶端調用

總結

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆