2. 程式人生 > >設計模式學習--原型模式

設計模式學習--原型模式

阿新 • • 發佈：2017-10-12
需要 dex throws 測試類 enc 接口 打印 getc 創建對象

原型模式（Prototype）：用原型實例指定創建對象的 種類，並且通過拷貝這些原型創建新的對象。

原型模式結構圖：

技術分享

原型模式涉及深克隆和淺克隆。

案例需求：制作一份簡歷，並復制三份。

第一次克隆實現：

1：創建簡歷類。

package PrototypeModel;

/**
 * 簡歷類
 * @author 我不是張英俊
 *
 */
public class Resume implements Cloneable {

    private String name;
    private String sex;
    private String age;
    private
 
 String timeArea;
    private String company;
    
    public Resume(){
        
    }
    public Resume(String name){
        this.name=name;
    }
    
    //設置個人信息
    public void SetPersonalInfo(String sex,String age){
        this.sex=sex;
        this.age=age;
    }
    
    //設置工作經歷
    public void
 
 SetWorkExperience(String timeArea,String company){
        this.timeArea=timeArea;
        this.company=company;
    }
    
    //顯示
    public void Display(){
        System.out.println(name+"    "+sex+"    "+age);
        System.out.println("工作經歷:"+timeArea+"    "+company);
    }
    
    public Object Copy() throws
 
 CloneNotSupportedException {
        return this;
    }    
    
    public Object clone() throws CloneNotSupportedException{
        //調用父類Object中的clone方法實現淺克隆
        return super.clone();
    }
}

2：創建測試類

package PrototypeModel;

/**
 * 簡歷復印，打印一份簡歷，並復印三份；
 * 原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。
 * @author 我不是張英俊
 *
 */
public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {

        Resume a=new Resume("旺財");
        a.SetPersonalInfo("男", "19");
        a.SetWorkExperience("1998-2-3", "百度");
        
        /**
         * Cpoy 方法中的是return this，
         * 返回的是索引，即返回的是指向堆中a對象的索引，
         * 所以，不論怎麽重新改變屬性，最終改變的都是a對象中的屬性，
         * 而此時，並沒有在堆中重新copy出兩個新的對象b和c。
         * 所以，應該用clone方法來實行，
         * 繼承Cloneable接口，並且重寫Object中的clone方法。
         * Cloneable接口是一個空的接口，它只是表明，可以重寫clone方法，若不實現此接口，不可以重寫clone方法
         * 此處使用的是淺克隆。
         */
        Resume b= (Resume) a.Copy();
        Resume b1=(Resume) a.clone();
        b.SetWorkExperience("2019-02-06", "360");
        
        Resume c=(Resume) a.Copy();
        Resume c1=(Resume) a.clone();
        a.SetWorkExperience("2016-03-02", "阿裏");
        
        System.out.println("a=  "+a);
        System.out.println("b=  "+b);
        System.out.println("c=  "+c);
        System.out.println("b1= "+b1);
        System.out.println("c1= "+c1);
        /**
         * 控制臺輸出發現克隆的索引不同，即創建出了新的對象。
         */
        a.Display();
        b.Display();
        c.Display();
        
        a.Display();
        b1.Display();
        c1.Display();
    }

}

3：控制臺

a=  [email protected]
b=  [email protected]
c=  [email protected]
b1= [email protected]
c1= [email protected]
旺財    男    19
工作經歷:2016-03-02    阿裏
旺財    男    19
工作經歷:2016-03-02    阿裏
旺財    男    19
工作經歷:2016-03-02    阿裏
旺財    男    19
工作經歷:2016-03-02    阿裏
旺財    男    19
工作經歷:1998-2-3    百度
旺財    男    19
工作經歷:2019-02-06    360

a,b,c三個的地址相同，說明return this返回當前對象的時候返回的是索引，他們指向同一個對象。

而b1，c1地址不同，說明是利用clone方法創建了新的對象。

super.clone()返回的是Object類型的。利用Object類中的clone方法來進行淺克隆。重寫Object類中的clone方法需要實現Cloneable接口。

其中Cloneable接口是一個空接口，它只是表明你可以重寫clone方法，不實現重寫的話，會拋出異常。

第二次克隆實現

事實上在實際開發過程中，工作經歷通常會做成工作經歷類，這樣，就需要深克隆。

先看如果使用淺克隆導致的問題：

1：創建工作經歷類。

package PrototypeModel2;

public class workExperence {

    private String workDate;
    private String company;
    public String getWorkDate() {
        return workDate;
    }
    public void setWorkDate(String workDate) {
        this.workDate = workDate;
    }
    public String getCompany() {
        return company;
    }
    public void setCompany(String company) {
        this.company = company;
    }
}

2：創建簡歷類。

package PrototypeModel2;

public class Resume implements Cloneable {

    private String name;
    private String sex;
    private String age;
    private workExperence work;
     
    public Resume(String name){
        this.name=name;
        work=new workExperence();
    }
    
    //設置個人信息
    public void setPersonalInfo(String sex,String age){
        this.sex=sex;
        this.age=age;
    }
    
    //設置工作經歷
    public void setWorkExperience(String workDate,String company){
        work.setCompany(company);
        work.setWorkDate(workDate);
    }
    //顯示
    public void display(){
        System.out.println(name+"    "+sex+"    "+age);
        System.out.println(work.getCompany()+"      "+work.getWorkDate());
    }
    
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

3：測試類。

package PrototypeModel2;

/**
 * 淺克隆會導致的問題
 * 制作簡歷
 * 實際開發中，會將工作經歷作為一個類，
 * @author 我不是張英俊
 *
 */
public class Test {

    public static void main(String arg[]) throws CloneNotSupportedException{
        Resume a=new Resume("旺財");
        a.setPersonalInfo("男", "26");
        a.setWorkExperience("2016-1017", "阿裏");
        
        Resume b=(Resume) a.clone();
        b.setWorkExperience("2017-2018", "360");
        
        Resume c=(Resume) a.clone();
        a.setWorkExperience("2018-2019", "騰訊");
        
        a.display();
        b.display();
        c.display();
    }
}

4：控制臺。

旺財    男    26
騰訊      2018-2019
旺財    男    26
騰訊      2018-2019
旺財    男    26
騰訊      2018-2019

原因：堆內存中只存在一個workExperience類，所以在修改的時候，總是修改同一個類中的數據，雖然克隆了不同的Resume對象，但不同的Resume對象確是調用同一個workExperience中的數據，所以最後輸出的都是最後修改的。

因為clone()方法，對於引用類型，克隆的是其引用，所以，當改變值得時候，就會出現相同的結果。因為三個引用都指向了同一個對象，即唯一的workExperience對象。

如果想顯示不同的，就必須對workExperience進行克隆，這樣每一個引用不同的workExperience就不會出現這種問題。

第三次克隆實現：

1：創建工作經歷類

package PrototypeModel1;
/**
 * 工作經歷類
 * @author 我不是張英俊
 *
 */
public class WorkExperience implements Cloneable {

    private String workDate;
    private String company;
    public String getWorkDate() {
        return workDate;
    }
    public void setWorkDate(String workDate) {
        this.workDate = workDate;
    }
    public String getCompany() {
        return company;
    }
    public void setCompany(String company) {
        this.company = company;
    }
    
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

2：創建一個簡歷類。

package PrototypeModel1;

public class Resume implements Cloneable {

    private String name ;
    private String sex;
    private String age;
    private WorkExperience work;
    
    public Resume(String name){
        this.name=name;
        work=new WorkExperience();
    }
    /*
     *提供clone方法調用的私有構造函數，以便克隆“工作經歷”的數據 
     */
    private Resume(WorkExperience work) throws CloneNotSupportedException{
        this.work=(WorkExperience) work.clone();
    }
    
    //設置個人信息
    public void setPersonalInfo(String sex,String age){
        this.sex=sex;
        this.age=age;
    }
    
    //設置工作經歷
    public void setWorkExperience(String workDate,String company){
        
        work.setCompany(company);
        work.setWorkDate(workDate);
    }
    
    //展示
    public void display(){
        System.out.println(name+"    "+sex+"    "+age);
        System.out.println("工作經歷    "+work.getCompany()+"      "+work.getWorkDate());
    }
    
    public Object clone() throws CloneNotSupportedException{
        /**
         * 調用私有的構造方法，讓“工作經歷”克隆完成，然後再給這個“簡歷”
         * 對象相關字段賦值，最終返回一個深克隆的簡歷對象。
         */
        Resume obj=new Resume(this.work);
        obj.age=this.age;
        obj.name=this.name;
        obj.sex=this.sex;
        return obj;
    }
}

3：創建一個測試類。

package PrototypeModel1;

/**
 * 簡歷復印，
 * 原型模式，
 * 深拷貝和淺拷貝
 * @author 我不是張英俊
 *
 */
public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {
        Resume a =new Resume("旺財");
        a.setPersonalInfo("男", "19");
        a.setWorkExperience("2019-2020", "阿裏");
        
        Resume b=(Resume)a.clone();
        b.setWorkExperience("2017-2018", "騰訊");
        
        Resume c=(Resume)a.clone();
        c.setWorkExperience("2016-2017", "華為");
        
        a.display();
        b.display();
        c.display();
    }

}

4：控制臺。

旺財 男 19
工作經歷 阿裏 2019-2020
旺財 男 19
工作經歷 騰訊 2017-2018
旺財 男 19
工作經歷 華為 2016-2017

利用深克隆解決問題。創建了堆內存中實際存在了三個workExperience對象。

總結：理解尚淺，暫時未想到。

設計模式學習--原型模式

相關推薦

設計模式學習--原型模式

需要 dex throws 測試類 enc 接口 打印 getc 創建對象 原型模式（Prototype）：用原型實例指定創建對象的 種類，並且通過拷貝這些原型創建新的對象。 原型模式結構圖： 原型模式涉及深克隆和淺克隆。 案例需求：制作一份簡歷，並復制三份。 第一次

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

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

設計模式學習總結（2）單例模式、建造者模式、原型模式

單例模式（Singleton Pattern） 這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其唯一的物件的方式，可以直接訪問，不需要例項化該類的物件。 單例模式有以下三點注意： 1、單例類只能有一個例項。 2、單

.net設計模式 （原型模式）學習筆記

運用設計模式只是為了解決一類問題的，當解決掉當前一類問題，通常會在解決這個問題時候 帶來其他問題  合理應用揚長避短 建立型模式：                    

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

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

設計模式學習——工廠模式（Factory Pattern）

cto ret cas .exe on() 生產 delet 基礎 names 1、有一個工廠，專門生產不同品牌的汽車。當有人需要從此工廠提貨的時候，只需要告訴他，要什麽品牌的，就可以了，並不關心這些車是怎麽生產出來的。 2、以上方式，如果增加品牌的時候，也要修改工廠，有點

Head First設計模式之原型模式

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

設計模式學習——代理模式（Proxy Pattern）

pre .cn mar str ubuntu 技術 運行 obj proxy 放假啦~學生們要買車票回家了，有汽車票、火車票，等。但是，車站很遠，又要考試，怎麽辦呢？找代理買啊，雖然要多花點錢，但是，說不定在搞活動，有折扣呢~ 1 /// 2 /// @fi

06.設計模式_原型模式

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

設計模式學習——代理模式（Proxy Pattern）之 強制代理（強校驗，防繞過）

arr cnblogs 其他 測試 auth using color ref use 上周溫習了代理模式：http://www.cnblogs.com/chinxi/p/7354779.html 在此進行拓展，學習強制代理。但是發現網上大多例子都有個“天坑”（我是這麽認為的

【Unity與23種設計模式】原型模式（Prototype）

模式 設計模式 unity 復制 ref 遊戲對象 代碼 設計 程序代碼 GoF中定義： “使用原型對象來產生指定類的對象，所以產生對象時，是使用復制原型對象來完成。” Unity中 開發者可以組裝遊戲對象 它可以包括復雜的組件 組裝好了之後，就可以將其存儲為Pre

（@WhiteTaken）設計模式學習——代理模式

imp 模式 ati lan public eth object 靜態代理 out 今天學習了一下代理模式，代理模式分為很多種。目前感覺有兩種是需要學習一下的。 靜態代理模式 動態代理模式 1. 靜態代理模式 　　需要被代理的類，實現一個或者多個接口。 　　代理類需要實

（@WhiteTaken）設計模式學習——組合模式

合成 concrete cnblogs java mil 使用 for -- 總公司 下面來學習一下組合模式。 組合模式概念是什麽呢。從別的地方抄來了一些理論。 理論：將對象組合成樹形結構以表示“部分-整體”的層次結構。Composite模式使得用戶對單個對象和組合對象的使

PHP設計模式：原型模式

php 設計模式 原型模式 sdfasd<?php /** * 原型模式(深拷貝+淺拷貝) */ declare(strict_types=1);//開啟強類型模式 class CopyObj { public $array; } //抽象原型類 abstract class

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

設計 公司 ext spa type img 存在 變化 new 一,原型模式：通過將一個原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。 using System; using System.Collections.Gene

關於js的設計模式（簡單工廠模式，構造函數模式，原型模式，混合模式，動態模式）

nod nodejs 重新 作用域 this 一次 無法 typeof 訪問 <1>工廠模式 簡單來說就是封裝後的代碼，簡單的工廠模式是很好理解的，關於它的作用，就是利用面向對象的方法，把一些對象封裝，使一些占用空間多的，重復的代碼封裝起來。實現方法非常簡單，也

4.泡妞與設計模式(五) 原型模式

最終 fin wchar_t 定制 pro 創建 示例 消息 類型 PROTOTYPE 原型模式 原型模式允許動態的增加或減少產品類，產品類不需要非得有任何事先確定的等級結構，原始模型模式適用於任何的等級結構。缺點是每一個類都必須配備一個克隆方法。(簡單點說就是調用的都可以

設計模式_創建型模式_原型模式

image 現在 抽象類 擴展 program pri this 遇到 原型 轉載自：http://blog.csdn.net/lovelion 作者：劉偉 原型模式(Prototype Pattern)：使用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的

go設計模式之原型模式

tin ros oge soft 高效 errors %d light 相等 　　原型模式是創建型模式的一種，其特點在於通過“復制”一個已經存在的實例來返回新的實例,而不是新建實例。被復制的實例就是我們所稱的“原型”，這個原型是可定制的。原型模式多用於創建復雜的或者耗時的實

設計模式之原型模式

name 原形 ace pre 我們 指定 通過 值類型 常常 原型模式（Prototype Pattern）：用原型實例指定創建對象的種類，並且通過復制這些原型創建新的對象。 作用(解決的問題)：簡化對象的創建過程。 優點： 1、當創建對象的實例較為復雜的時候，使用原型模