2. 程式人生 > >一天一個設計模式(四) - 原型模式(Prototype)

一天一個設計模式(四) - 原型模式(Prototype)

阿新 • • 發佈：2018-09-24
管理員 ans rip prototype register 性能 除了 func comm

前言

原型模式屬於對象的創建模式。通過給出一個原型對象來指明所有創建的對象的類型，然後用這個原型對象提供的復制辦法創建出更多同類型的對象。

原型模式的結構

原型模式要求對象實現一個可以克隆自身的接口(類型)。這樣一來，通過原型實例創建新的對象，就不需要關心這個實例本身的類型，只需要實現克隆自身的方法，也而無需再去通過new來創建。

原型類型的表現形式

  1. 簡單形式
  2. 登記形式

正文

簡單形式

技術分享圖片

相關角色

  1. 客戶(Client)角色：客戶類提出創建對象的請求；
  2. 抽象原型(Prototype)角色：這是一個抽象角色，通常由一個Java接口或者Java抽象類實現。此角色定義了的具體原型類所需的實現的方法。
  3. 具體原型(Concrete Prototype)角色：此角色需要實現抽象原型角色要求的克隆相關的接口。

示例代碼

Prototype.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
/**
 * 抽象原型角色
 */
public abstract class Prototype {
    private String id;

    public Prototype(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

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

    /**
     * 克隆自身的方法
     * @return 一個從自身克隆出來的對象。
     */
    public abstract Prototype clone();
}

ConcretePrototype1.java

1
2
3
4
5
6
7
8
9
10
 
public class ConcretePrototype1 extends Prototype {
    public ConcretePrototype1(String id) {
        super(id);
    }

    public Prototype clone() {
        Prototype prototype = new ConcretePrototype1(this.getId());
        return prototype;
    }
}

ConcretePrototype2.java

1
2
3
4
5
6
7
8
9
10
 
public class ConcretePrototype2 extends Prototype {
    public ConcretePrototype2(String id) {
        super(id);
    }

    public Prototype clone() {
        Prototype prototype = new ConcretePrototype2(this.getId());
        return prototype;
    }
}

運行結果

技術分享圖片

登記形式

技術分享圖片

相關角色

  1. 客戶(Client)角色：客戶類提出創建對象的請求；
  2. 抽象原型(Prototype)角色：這是一個抽象角色，通常由一個Java接口或者Java抽象類實現。此角色定義了的具體原型類所需的實現的方法。
  3. 具體原型(Concrete Prototype)角色：此角色需要實現抽象原型角色要求的克隆相關的接口。
  4. 原型管理器(Prototype Manager)角色：提供各種原型對象的創建和管理。

示例代碼

除了原型管理器Prototype Manager以外，登記模式和簡單模式並無其他差異。

Prototype.java
W

1
2
3
4
5
 
public interface Prototype {
    public Prototype clone();
    public String getName();
    public void setName(String name);
}

ConcretePrototype1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public class ConcretePrototype1 implements Prototype {
    private String name;

    @Override
    public String getName() {
        return this.name;
    }

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

    @Override
    public Prototype clone() {
        Prototype prototype = new ConcretePrototype1();
        prototype.setName(this.name);
        return prototype;
    }

    @Override
    public String toString() {
        return "ConcretePrototype1 [name=" + name + "]";
    }

}

ConcretePrototype2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class ConcretePrototype2 implements Prototype {
    private String name;

    @Override
    public String getName() {
        return this.name;
    }

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

    @Override
    public Prototype clone() {
        Prototype prototype = new ConcretePrototype2();
        prototype.setName(this.name);
        return prototype;
    }

    @Override
    public String toString() {
        return "ConcretePrototype2 [name=" + name + "]";
    }
}

PrototypeManager.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
public class PrototypeManager {
    /**
     * 用來記錄原型的編號同原型實例的對象關系
     */
    private static Map<String, Prototype> map = new HashMap<>();

    /**
     * 私有化構造方法，避免從外部創建實例
     */
    private PrototypeManager() {
    }

    /**
     * 向原型管理器裏面添加或者修改原型實例
     *
     * @param prototypeId 原型編號
     * @param prototype   原型實例
     */
    public static void setProtoType(String prototypeId, Prototype prototype) {
        map.put(prototypeId, prototype);
    }

    /**
     * 根據原型編號從原型管理器裏面移除原型實例
     *
     * @param prototypeId 原型編號
     */
    public static void removePrototype(String prototypeId) {
        map.remove(prototypeId);
    }

    /**
     * 根據原型編號獲取原型實例
     *
     * @param prototypeId 原型編號
     * @return 原型實例對象
     * @throws Exception 如果根據原型編號無法獲取對應實例，則提示異常“您希望獲取的原型還沒有註冊或已被銷毀”
     */
    public static Prototype getPrototype(String prototypeId) throws Exception {
        Prototype prototype = map.get(prototypeId);

        if (prototype == null) {
            throw new Exception("您希望獲取的原型還沒有註冊或已被銷毀");
        }

        return prototype;
    }

}

Client.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
public class Client {
    public static void main(String[] args) {
        try {
            // 創建第一個實例
            Prototype p1 = new ConcretePrototype1();
            // 註冊第一個實例
            PrototypeManager.setProtoType("p1", p1);

            // 克隆第一個實例的原型
            Prototype p3 = PrototypeManager.getPrototype("p1").clone();
            p3.setName("張三");
            System.out.println("第一個實例的副本：" + p3);

            // 創建第二個實例
            Prototype p2 = new ConcretePrototype2();
            // 註冊第二個實例
            PrototypeManager.setProtoType("p2", p2);

            // 克隆第二個實例的原型
            Prototype p4 = PrototypeManager.getPrototype("p2").clone();
            p4.setName("李四");
            System.out.println("第二個實例的副本：" + p4);

            // 註銷第一個實例
            PrototypeManager.removePrototype("p1");
            // 再次克隆第一個實例的原型
            Prototype p5 = PrototypeManager.getPrototype("p1").clone();
            p5.setName("王五");
            System.out.println("第一個實例的副本：" + p5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

運行結果

技術分享圖片

兩者之間的比較

簡單形式和登記形式的原型模式各有其長處和短處。

  1. 如果要創建的原型對象數據較少而且比較固定的話，可以采用第一種形式。在這種情況下，原型對象的引用可以由客戶端自己保存。
  2. 如果要創建的原型對象數據不固定的話，可以采用第二種形式。在這種情況下，客戶端不保存對原型對象的引用，這個任務被交給原型管理器角色。在克隆一個對象之前，客戶端可以查看管理員對象是否已經有一個滿足要求的原型對象。如果有，可以從原型管理器角色中取得這個對象引用；如果沒有，客戶端就需要自行復制此原型對象。

總結

原型模式的優點

原型模式允許在運行時動態改變具體的實現類型。原型模式可以在運行期間，有客戶來註冊符合原型接口的實現類型，也可以動態的改變具體的實現類型，看起來接口沒有任何變化，但是其實運行的已經是另外一個類實體了。因為克隆一個原型對象就類似於實例化一個類。

原型模式的缺點

原型模式最主要的缺點是每一個類都必須要配備一個克隆方法。配備克隆方法需要對類的功能進行通盤考慮，這對於全新的類來說並不是很難，但是對於已有的類來說並不容易。

歡迎關註技術公眾號： 零壹技術棧

技術分享圖片零壹技術棧

本帳號將持續分享後端技術幹貨，包括虛擬機基礎，多線程編程，高性能框架，異步、緩存和消息中間件，分布式和微服務，架構學習和進階等學習資料和文章。

一天一個設計模式(四) - 原型模式(Prototype)

相關推薦

一天一個設計模式(四) - 原型模式(Prototype)

管理員 ans rip prototype register 性能 除了 func comm 前言 原型模式屬於對象的創建模式。通過給出一個原型對象來指明所有創建的對象的類型，然後用這個原型對象提供的復制辦法創建出更多同類型的對象。 原型模式的結構 原型模式要求對象實現

一天一個設計模式(五) - 適配器模式(Adapter)

p s func 靈活性 nsh ans target 多線程 isp pattern 前言 適配器模式把一個類的接口變換成客戶端所期待的另一種接口，從而使原本因接口不匹配而無法在一起工作的兩個類能夠在一起工作。 適配器模式的用途 最經典的就是電器的例子，筆記本電腦的插

一天一個設計模式(一) - 總體概述

享元 關註 責任鏈 分布式 分享圖片 模板方法 mage upload 抽象工廠 前言 最近在對設計模式進行了一系列總結，本文將給大家關於設計模式的一個整體的介紹。 正文 1. 定義 設計模式是某類特定問題的代碼設計解決方案，是一套代碼設計的經驗總結。 2. 作用 提高

一天一個設計模式：介面卡模式

概念： 　　介面卡模式是把一個類的介面變成客戶端所期待的另一種介面，從而使原本因介面不匹配而無法在一起工作的兩個類能夠在一起工作。 用途： 　　就像插頭轉換器，之前入了switch港版，插頭是英式的，還好附贈一個插頭轉換器，介面卡就相當於這個轉換器。 種類： 　　分為類的介面卡與物件的介面卡兩種

一天一個設計模式：工廠方法模式

工廠方法模式： 　　定義一個生產產品物件的工廠介面，將建立生產產品的工廠的工作交給子類實現。 　　隨著實際需要的工廠數量增加，簡單工廠模式體積會迅速膨脹，程式碼迅速臃腫嚴重。　　補充：工廠方法模式是針對一類產品的工廠 　　所以為了程式碼的可閱讀下與可維護性，也做到不同的業務有一定的隔離，將工廠的功能抽象出來成

一天一個設計模式：裝飾者模式

概念： 　　裝飾者模式又稱為包裝(wrapper)模式。裝飾者模式對客戶端透明的方式擴充套件物件的功能，是繼承關係的一個替代方案。 結構： 　　裝飾者模式以透明的方式給一個物件附加上更多的責任，換而言之，客戶端並不會覺得物件在裝飾前後有什麼不同，裝飾者模式可以在不使用創造更多子類的情況下，將物件的功能拓展。

一天一個設計模式：策略模式

概念： 　　策略模式屬於物件的行為模式，其用意是針對一組演算法，將每一個演算法封裝到具有共同介面的獨立的類中，從而使得它們可以相互替換。策略模式使得演算法可以在不影響客戶端的情況下變化。 結構： 環境(Context)角色：持有一個Strategy的引用。 抽象策略(Strategy)角色：這是一個抽象角色

一天一個設計模式：抽象方法模式

為什麼引入抽象工廠模式? 或者說抽象工廠模式與工廠方法模式的區別？ 工廠方法模式針對的是一類產品的等級結構，而抽象工廠模式針對的是多個產品等級結構（一個產品族）。 引入概念：產品族與產品等級 產品族：指在不同的產品等級結構中，功能相關聯的產品組成的家族。產品等級：同類產品的不同產品區分。 抽象工廠的作用：

一天一個設計模式：建造模式

概念： 　　建造模式是物件的建立模式，建造模式可以將一個產品的內部表象（個人理解，可以稱為元件）與產品的生產分割開來，從而可以使一個建造過程生產出來具有不同內部表象的產品物件。 概念： 產品的內部表象： 　　產品不同組成成分構成（元件）這些零件可以是物件，也可以是非物件，稱為內部表象（internal re

一天一個設計模式：單例模式

概念： 　　作為物件的建立模式，單例模式確保某一個類只有一個例項，而且自行例項化，並向整個系統提供這個例項。 特點： 　　1.單例類只能有一個例項 　　2.單例類必須建立自己的唯一例項 　　3.單例類必須給其他所有物件提供這一例項。 餓漢式單例類 public class EagerSingleton {

一天一個設計模式：模板方法模式

概念： 　　模板方法模式是類的行為模式，準備一個抽象類，將部分邏輯以具體方法以及具體建構函式的形式實現，然後宣告一些抽象方法來迫使子類實現剩餘的邏輯。不同的子類可以以不同的方式實現這些抽象方法，從而對剩餘的邏輯有不同的實現。這就是模板方法模式的意思。 結構： 　　模板方法模式中，抽象類負責定義整個的邏輯框架，

一天一個設計模式---裝飾者模式

優點：它可以動態為物件新增功能。 場景：我們希望為某個物件而不是整個類新增一些功能。 一、角色及作用 裝飾者和被裝飾者擁有相同的元件介面。被裝飾者是系統的核心元件，完成特定功能。裝飾者則可以在被裝飾者的方法前後，加上特定的前置處理和後置處理，增強被裝飾

一天學習一個設計模式之原型模式

拷貝 pre des prot transient ret 哈哈 his 耗時 原型模式（Prototype),用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。 　　原型模式其實就是從一個對象再創建另外一個可定制的對象，而且不需要知道任何創建的細節。例

四、Python 設計模式之原型模式

原型模式的目的是克隆物件 或者 副本 類似於淺拷貝和深拷貝 淺拷貝就是 副本依賴引用 深拷貝就是 完全克隆一份 以下是簡單的例子 import copy class A: def __init__(self): self.x = 18

設計模式筆記之四原型模式

原型模式 為什麼引入原型模式？ 當我們需要建立某個物件的時候，我們使用new關鍵字，但是當我們需要建立兩個相同的物件，接著new,當數量特定少的時候，我們可以採用直接建立物件，但是當我們需要建立很多物件的時候，我們就不能一直new，首先是因為堆記憶體有限，只允許我們new

一天一種設計模式——狀態模式

作用：當人物有複雜的狀態轉換時使用 Context：狀態擁有者 State：狀態的介面類 狀態擁有著持有一個狀態的介面類，在構造方法時定義其狀態 狀態的介面類中持有狀態的擁有者，可在每一個狀態內部切換其狀態擁有者的狀態 //程式碼執行 public class Text { Contex

Java程式設計師從笨鳥到菜鳥之（三十四）大話設計模式（五）建立者模式和原型模式

        建立者模式是建立型模式中最負責的一個設計模式了，建立者負責構建一個物件的各個部分，並且完成組裝的過程.構建模式主要用來針對複雜產品生產，分離部件構建細節，以達到良好的伸縮性。把構造物件例項的邏輯移到了類的外部，在這個類外部定義了這個類的構造邏輯。它把一個複雜物件的構過程從物件的表示中分離

JavaScript設計模式-3.原型模式

掛載 r+ eof style 數據 默認 per blog script 1 <!DOCTYPE html> 2 <html> 3 <head> 4 <meta charset="UTF-8"&g

Head First設計模式之原型模式

webkit ble -1 否則 type sof 異常 構圖 etc 用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。 原型模式是一種比較簡單的模式，也非常容易理解，實現一個接口，重寫一個方法即完成了原型模式。在實際應用中，原型模式很少單獨出現。經常與其

06.設計模式_原型模式

拷貝 lin con 動態 工廠模式 人的 孫悟空 sum nbsp 轉載自 http://www.cnblogs.com/zhili/p/PrototypePattern.html 一、引言 在軟件系統中，當創建一個類的實例的過程很昂貴或很復雜，並且我們需要創建多個這樣類