2. 程式人生 > 其它 >設計模式:原型模式(物件構造方法之前賦值,構造方法巢狀,克隆)

設計模式:原型模式(物件構造方法之前賦值,構造方法巢狀,克隆)

阿新 • • 發佈：2021-01-24

技術標籤：設計模式

原型模式主要解決的問題就是建立重複物件,而這部分物件內容本身⽐較複雜，生成過程可能從庫或者RPC接⼝(遠端介面呼叫)中獲取資料的耗時較長，因此採用克隆的方式節省時間,clone方法最終將呼叫JVM中的原生方法完成複製也就是呼叫底層的c++程式碼.
根據自己的開發業務經驗感覺此模式主要適用於物件大部分屬性相同,但部分屬性不同的場景.比如說考試的試卷,每個人的考題是相同的,但是姓名和學號是不同的.就這一場景進行模擬一下 .要求:小明 小紅輸入姓名以及學號之後就能看到自己的考題內容.
考題單元內容:

public class TestQuestionsUnit {
    // 題目
 

    private String question;
    // 題目選項內容
    private Map<String,String> questionMap;
    // 答案
    private String answer;

	// 省略get/set..

    @Override
    public String toString() {
        return "TestQuestions{" +
                "question='" + question + '\'' +
                ", questionMap="
 
 + questionMap +
                ", answer='" + answer + '\'' +
                '}';
    }
}

試卷:

public class TestQuestions {
   
    // 姓名
    private String name;
    // 考試編號
    private String no;
    // 考試題目集合
    private  List<TestQuestionsUnit> testQuestionsUnitList;

   // 省略get/set..
 

   
    @Override
    public String toString() {
        return "TestQuestions{" +
                "name='" + this.name + '\'' +
                ", no='" + this.no + '\'' +
                ", testQuestionsUnitList='" + testQuestionsUnitList + '\'' +
                '}';
    }
}

分發考卷1.0:

 public static void main(String[] args) {
        // 給小明建立考卷
        // 構造題庫
        ArrayList<TestQuestionsUnit> testQuestionsUnits = new ArrayList<>();
        // 第一題
        TestQuestionsUnit testQuestionsUnit = new TestQuestionsUnit();
        testQuestionsUnit.setQuestion("水的沸點是多少度( )");
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("A","97攝氏度");
        hashMap.put("B","98攝氏度");
        hashMap.put("C","99攝氏度");
        hashMap.put("D","100攝氏度");
        testQuestionsUnit.setQuestionMap(hashMap);
        testQuestionsUnits.add(testQuestionsUnit);

        // 第二題
        TestQuestionsUnit testQuestionsUnit2 = new TestQuestionsUnit();
        testQuestionsUnit2.setQuestion("一天有多少個小時( )");
        HashMap<String, String> hashMap2 = new HashMap<>();
        hashMap2.put("A","48");
        hashMap2.put("B","36");
        hashMap2.put("C","24");
        hashMap2.put("D","12");
        testQuestionsUnit2.setQuestionMap(hashMap2);
        testQuestionsUnits.add(testQuestionsUnit2);

        // 第三題
        TestQuestionsUnit testQuestionsUnit3 = new TestQuestionsUnit();
        testQuestionsUnit3.setQuestion("先有雞還是先有蛋?");
        testQuestionsUnits.add(testQuestionsUnit3);
        TestQuestions testQuestions = new TestQuestions();
        testQuestions.setName("小明");
        testQuestions.setNo("0001");
        testQuestions.setTestQuestionsUnitList(testQuestionsUnits);
        System.out.println("小明試卷:"+testQuestions);

        // 給小紅建立考卷
        // 構造題庫
        ArrayList<TestQuestionsUnit> testQuestionsUnits2 = new ArrayList<>();
        // 第一題
        TestQuestionsUnit testQuestionsUnit21 = new TestQuestionsUnit();
        testQuestionsUnit21.setQuestion("水的沸點是多少度( )");
        HashMap<String, String> hashMap21 = new HashMap<>();
        hashMap21.put("A","97攝氏度");
        hashMap21.put("B","98攝氏度");
        hashMap21.put("C","99攝氏度");
        hashMap21.put("D","100攝氏度");
        testQuestionsUnit21.setQuestionMap(hashMap21);
        testQuestionsUnits2.add(testQuestionsUnit21);

        // 第二題
        TestQuestionsUnit testQuestionsUnit22 = new TestQuestionsUnit();
        testQuestionsUnit22.setQuestion("一天有多少個小時( )");
        HashMap<String, String> hashMap22 = new HashMap<>();
        hashMap22.put("A","48");
        hashMap22.put("B","36");
        hashMap22.put("C","24");
        hashMap22.put("D","12");
        testQuestionsUnit2.setQuestionMap(hashMap22);
        testQuestionsUnits2.add(testQuestionsUnit2);

        // 第三題
        TestQuestionsUnit testQuestionsUnit23 = new TestQuestionsUnit();
        testQuestionsUnit23.setQuestion("先有雞還是先有蛋?");
        testQuestionsUnits2.add(testQuestionsUnit23);
        TestQuestions testQuestions2 = new TestQuestions();
        testQuestions2.setName("小紅");
        testQuestions2.setNo("0002");
        testQuestions2.setTestQuestionsUnitList(testQuestionsUnits2);
        System.out.println("小紅試卷:"+testQuestions2);
    }

分發考卷1.0輸出內容:

小明試卷:TestQuestions{name='小明', no='0001', testQuestionsUnitList='[TestQuestions{question='水的沸點是多少度( )', questionMap={A=97攝氏度, B=98攝氏度, C=99攝氏度, D=100攝氏度}, answer='null'}, TestQuestions{question='一天有多少個小時( )', questionMap={A=48, B=36, C=24, D=12}, answer='null'}, TestQuestions{question='先有雞還是先有蛋?', questionMap=null, answer='null'}]'}
小紅試卷:TestQuestions{name='小紅', no='0002', testQuestionsUnitList='[TestQuestions{question='水的沸點是多少度( )', questionMap={A=97攝氏度, B=98攝氏度, C=99攝氏度, D=100攝氏度}, answer='null'}, TestQuestions{question='一天有多少個小時( )', questionMap={A=48, B=36, C=24, D=12}, answer='null'}, TestQuestions{question='先有雞還是先有蛋?', questionMap=null, answer='null'}]'}

發現試題內容都是相同的,所以考慮將試題內容在建立考卷的初始化中將試題建立完成,這裡採用靜態程式碼塊的方式在考卷構造方法之前將考題內容載入到考卷中,所以有了考卷2.0:

public class TestQuestions {

	// 初始化考題內容 
    static {
        // 構造方法之前初始化題庫
        ArrayList<TestQuestionsUnit> testQuestionsUnits = new ArrayList<>();
        // 第一題
        TestQuestionsUnit testQuestionsUnit = new TestQuestionsUnit();
        testQuestionsUnit.setQuestion("水的沸點是多少度( )");
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("A","97攝氏度");
        hashMap.put("B","98攝氏度");
        hashMap.put("C","99攝氏度");
        hashMap.put("D","100攝氏度");
        testQuestionsUnit.setQuestionMap(hashMap);
        testQuestionsUnits.add(testQuestionsUnit);

        // 第二題
        TestQuestionsUnit testQuestionsUnit2 = new TestQuestionsUnit();
        testQuestionsUnit2.setQuestion("一天有多少個小時( )");
        HashMap<String, String> hashMap2 = new HashMap<>();
        hashMap.put("A","48");
        hashMap.put("B","36");
        hashMap.put("C","24");
        hashMap.put("D","12");
        testQuestionsUnit2.setQuestionMap(hashMap);
        testQuestionsUnits.add(testQuestionsUnit2);

        // 第三題
        TestQuestionsUnit testQuestionsUnit3 = new TestQuestionsUnit();
        testQuestionsUnit3.setQuestion("先有雞還是先有蛋?");
        testQuestionsUnits.add(testQuestionsUnit3);
        TestQuestions.testQuestionsUnitList=testQuestionsUnits;
    }
    
    // 姓名
    private String name;
    // 考試編號
    private String no;
    // 考試題目集合,此處應為靜態變數,否則無法在靜態程式碼塊中呼叫
    private static   List<TestQuestionsUnit> testQuestionsUnitList;

	// 無參構造
    public TestQuestions() {
    }
    
	// 全參構造(兩個引數) 
    public TestQuestions(String name, String no) {
        this.name = name;
        this.no = no;
        new TestQuestions(name,no,testQuestionsUnitList); // 呼叫三個引數的構造方法,或是使用下面的呼叫三個引數的構造方法(必須保證在構造方法的第一行,否則idea會報錯)
        //this(name,no,testQuestionsUnitList);
    }
    
    // 全參構造(三個引數) 
    public TestQuestions(String name, String no,List<TestQuestionsUnit> testQuestionsUnitList) {
        this.name = name;
        this.no = no;
    }

// 省略get/set....

    @Override
    public String toString() {
        return "TestQuestions{" +
                "name='" + this.name + '\'' +
                ", no='" + this.no + '\'' +
                ", testQuestionsUnitList='" + testQuestionsUnitList + '\'' +
                '}';
    }
}

分發考卷2.0:

public static void main(String[] args) {
    TestQuestions te = new TestQuestions("小明", "001");
    TestQuestions te1 = new TestQuestions("小紅", "002");
    System.out.println(te);
    System.out.println(te1);
}

輸出結果:

小明試卷:TestQuestions{name='小明', no='0001', testQuestionsUnitList='[TestQuestions{question='水的沸點是多少度( )', questionMap={A=97攝氏度, B=98攝氏度, C=99攝氏度, D=100攝氏度}, answer='null'}, TestQuestions{question='一天有多少個小時( )', questionMap={A=48, B=36, C=24, D=12}, answer='null'}, TestQuestions{question='先有雞還是先有蛋?', questionMap=null, answer='null'}]'}
小紅試卷:TestQuestions{name='小紅', no='0002', testQuestionsUnitList='[TestQuestions{question='水的沸點是多少度( )', questionMap={A=97攝氏度, B=98攝氏度, C=99攝氏度, D=100攝氏度}, answer='null'}, TestQuestions{question='一天有多少個小時( )', questionMap={A=48, B=36, C=24, D=12}, answer='null'}, TestQuestions{question='先有雞還是先有蛋?', questionMap=null, answer='null'}]'}

是不是感覺清爽多了,但是使用new的方式建立大量物件(屬性大部分相同)耗時是非常多的,原型模式解決的建立相同物件的耗時問題.原因是原型模式中呼叫clone方法,clone比new優越性在於:new物件需要執行構造方法進行初始化操作,而clone方法不需要呼叫構造方法,執行效率上clone要更高;
考卷3.0(原型模式):

public class TestQuestionsClone implements Cloneable  {

    static {
        System.out.println("靜態程式碼塊中邏輯執行");
        // 構造方法之前初始化題庫
        ArrayList<TestQuestionsUnit> testQuestionsUnits = new ArrayList<>();
        // 第一題
        TestQuestionsUnit testQuestionsUnit = new TestQuestionsUnit();
        testQuestionsUnit.setQuestion("水的沸點是多少度( )");
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("A","97攝氏度");
        hashMap.put("B","98攝氏度");
        hashMap.put("C","99攝氏度");
        hashMap.put("D","100攝氏度");
        testQuestionsUnit.setQuestionMap(hashMap);
        testQuestionsUnits.add(testQuestionsUnit);

        // 第二題
        TestQuestionsUnit testQuestionsUnit2 = new TestQuestionsUnit();
        testQuestionsUnit2.setQuestion("一天有多少個小時( )");
        HashMap<String, String> hashMap2 = new HashMap<>();
        hashMap.put("A","48");
        hashMap.put("B","36");
        hashMap.put("C","24");
        hashMap.put("D","12");
        testQuestionsUnit2.setQuestionMap(hashMap);
        testQuestionsUnits.add(testQuestionsUnit2);

        // 第三題
        TestQuestionsUnit testQuestionsUnit3 = new TestQuestionsUnit();
        testQuestionsUnit3.setQuestion("先有雞還是先有蛋?");
        testQuestionsUnits.add(testQuestionsUnit3);
        System.out.println("靜態程式碼塊中執行題庫初始化:"+testQuestionsUnits);
        TestQuestionsClone.testQuestionsUnitList=testQuestionsUnits;
        System.out.println("靜態程式碼塊中給題庫進行賦值結束");

    }

    // 姓名
    private String name;
    // 考試編號
    private String no;
    // 考試題目集合
    private static  List<TestQuestionsUnit> testQuestionsUnitList;

    public TestQuestionsClone(String name, String no) {
        this.name = name;
        this.no = no;
        new TestQuestions(name,no,testQuestionsUnitList); // 呼叫三個引數的構造方法,或是使用下面的呼叫三個引數的構造方法(必須保證在第一行,否則需要報錯)
        //this(name,no,testQuestionsUnitList);
    }

    public TestQuestionsClone(String name, String no,List<TestQuestionsUnit> testQuestionsUnitList) {
        this.name = name;
        this.no = no;
    }

	// 省略get/set方法

    @Override
    public String toString() {
        return "TestQuestions{" +
                "name='" + this.name + '\'' +
                ", no='" + this.no + '\'' +
                ", testQuestionsUnitList='" + testQuestionsUnitList + '\'' +
                '}';
    }
	// 繼承cloneable介面,重寫clone方法
    @Override
    public TestQuestionsClone clone() throws CloneNotSupportedException {
        return (TestQuestionsClone)super.clone();
    }
}

分發考卷3.0:

public static void main(String[] args) throws CloneNotSupportedException {
    TestQuestionsClone testQuestionsClone = new TestQuestionsClone("小明", "001");
    System.out.println(testQuestionsClone);
    TestQuestionsClone testQuestionsClone2 = testQuestionsClone.clone();
    testQuestionsClone2.setName("小紅");
    testQuestionsClone2.setNo("002");
    System.out.println(testQuestionsClone2);
}

輸出結果:

小明試卷:TestQuestions{name='小明', no='0001', testQuestionsUnitList='[TestQuestions{question='水的沸點是多少度( )', questionMap={A=97攝氏度, B=98攝氏度, C=99攝氏度, D=100攝氏度}, answer='null'}, TestQuestions{question='一天有多少個小時( )', questionMap={A=48, B=36, C=24, D=12}, answer='null'}, TestQuestions{question='先有雞還是先有蛋?', questionMap=null, answer='null'}]'}
小紅試卷:TestQuestions{name='小紅', no='0002', testQuestionsUnitList='[TestQuestions{question='水的沸點是多少度( )', questionMap={A=97攝氏度, B=98攝氏度, C=99攝氏度, D=100攝氏度}, answer='null'}, TestQuestions{question='一天有多少個小時( )', questionMap={A=48, B=36, C=24, D=12}, answer='null'}, TestQuestions{question='先有雞還是先有蛋?', questionMap=null, answer='null'}]'}

實際上就是在2.0的基礎上讓試卷物件繼承cloneable介面重寫clone方法.第一次使用new的方式進行建立,之後的每一次都使用克隆的方法進行建立;
下面測試new物件與clone物件的效率:

 public static void main(String[] args) throws CloneNotSupportedException {
        // 原型模式clone方法
        long start = System.currentTimeMillis();
            TestQuestionsClone testQuestionsClone = new TestQuestionsClone("小明0", "1");
        for (int i = 0; i < 1000; i++) {
            TestQuestionsClone testQuestionsClone2 = testQuestionsClone.clone();
            testQuestionsClone2.setName("小明"+String.valueOf(++i));
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);   // 耗時:2

		// new的方式建立物件
 		long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            TestQuestions te = new TestQuestions("小明", String.valueOf(i));
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);    // 耗時:19
    }

說到clone簡單說一下深克隆與淺克隆
淺克隆:建立新的物件,地址值改變,複製物件的基本型別值,如果物件中引用型別,引用還是指向原來的引用物件;考卷3.0中實際上是屬於淺克隆,可以列印一下TestQuestionsClone 中的引用testQuestionsUnitList的地址值,克隆出來的地址值與首次建立的TestQuestionsClone 中的引用testQuestionsUnitList的地址值相同;
深克隆:建立新的物件,地址值改變,複製物件的基本型別,如果物件有引用型別,則建立新的引用物件.深克隆與淺克隆的區別在於物件中存在引用的情況,實現深克隆可以將引用中的物件實現cloneable重寫clone方法或是實現Serializable介面.

相關推薦

設計模式:原型模式(物件構造方法之前賦值,構造方法巢狀,克隆)

技術標籤：設計模式 原型模式主要解決的問題就是建立重複物件,而這部分物件內容本身⽐較複雜，生成過程可能從庫或者RPC接⼝(遠端介面呼叫)中獲取資料的耗時較長，因此採用克隆的方式節省時間,clone方法最終將呼叫

詳解設計模式 原型模式

原型模式 原型模式屬於建立型設計模式 定義： 用原型例項指定建立物件的種類，並且通過拷貝這些原型建立新的物件

javascript設計模式 – 原型模式原理與應用例項分析

本文例項講述了javascript設計模式 – 原型模式原理與應用。分享給大家供大家參考，具體如下：

23種設計模式——原型模式

23種設計模式——原型模式 1.淺克隆 package com.mjh.prototype; import java.util.Date; /** * 實現一個介面Cloneable

設計模式 原型模式

1.設計模式背景 在某些場景下，我們需要拷貝物件，普通設計方式會直接new一個新的物件，然後setter各種屬性。缺點是：這種方式太麻煩。

設計模式-原型模式

一、原型模式的理解 當物件的建立比較複雜時，考慮使用原型模式將物件拷貝一份，拷貝分為深度拷貝和淺拷貝，所謂拷貝就是將物件的屬性拷貝的另一個物件中去，對於物件中的基本資料型別拷貝時為值傳遞，拷貝時直接將值

C#設計模式——原型模式

1.原型模式介紹 　　在軟體系統開發中，有時候會遇到這樣的情況：我們需要用到多個相同例項，最簡單直接的方法是通過多次呼叫new方法來建立相同的例項。如下：

設計模式——原型模式

原型模式（Prototype Pattern）：是用於建立重複物件，同時又能保證效能。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。這種模式是實現了一個原型介面，該介面用於建立當前物件的克隆。當直

C#設計模式-原型模式（Prototype Pattern）

引言 在軟體開發過程中，我們習慣使用new來建立物件。但是當我們建立一個例項的過程很昂貴或者很複雜，並且需要建立多個這樣的類的例項時。如果仍然用new操作符去建立這樣的類的例項，會導致記憶體中多分配一個一樣的

4.設計模式-建立型模式-原型模式

技術標籤：設計模式設計模式 一、原型模式 原型模式（Prototype Pattern）是用於copy方式建立基礎的重複物件，同時又能保證效能。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式之一，原型模

JAVA學習設計模式——原型模式

技術標籤：JAVA設計模式學習記錄設計模式學習java設計模式 目錄 原型模式簡介原型模式應用場景原型模式淺拷貝和深拷貝java中記憶體分配淺拷貝和深拷貝的區別

設計模式-原型模式，深拷貝，淺拷貝

原型模式： 原型模式其實就是從一個物件在建立另一個可定製的物件，而且不需要知道任何建立的細節

設計模式-建立者模式-原型模式

建立者模式-原型模式 1 概述 用一個已經建立的例項作為原型，通過複製該原型物件來建立一個和原型物件相同的新物件。

C++設計模式 - 原型模式（Prototype）

物件建立模式 通過“物件建立” 模式繞開new，來避免物件建立（new）過程中所導致的緊耦合（依賴具體類），從而支援物件建立的穩定。它是介面抽象之後的第一步工作。

設計模式 - 原型模式

目錄 概念 編碼 例項 淺克隆 深克隆 對於引用型別單獨克隆 序列化實現深克隆 總結

04-03-設計模式 原型模式

克隆羊問題 現在有一隻羊Tom, 姓名: Tom 年齡: 1, 顏色為白色, 編寫程式建立 和 Tom 羊屬性完全相同的10只羊

java反射機制反射屬性, 方法, 構造方法 / 設定屬性值, 呼叫方法, 呼叫構造方法

1. 獲取類名 // 1. 靜態方法Class c = Class.forName(\"類的路徑, 帶類包名\");// 2. 任何類都有 getName() 方法 返回類的名字// 3. 類的class屬性

Java物件不使用時賦值null的意義詳解

先看程式碼 public class TestDemo1 { public static void main(String[] args) { if (true) { byte[] placeHolder = new byte[64 * 1024 * 1024];

如何使用BeanUtils.copyProperties進行物件之間的屬性賦值

1、使用org.springframework.beans.BeanUtils.copyProperties方法進行物件之間屬性的賦值，避免通過get、set方法一個一個屬性的賦值

ES6中let、const的區別及變數的解構賦值操作方法例項分析

本文例項講述了ES6中let、const的區別及變數的解構賦值操作方法。分享給大家供大家參考，具體如下：