2. 程式人生 > >Java設計模式之五大創建型模式（附實例和詳解）

Java設計模式之五大創建型模式（附實例和詳解）

阿新 • • 發佈：2018-03-16
caf aac concrete 為什麽 ota pil sem 而不是 rtm

一、概況

總體來說設計模式分為三大類：

（1）創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
（2）結構型模式，共七種：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
（3）行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、叠代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。

二、設計模式的六大原則

1、開閉原則（Open Close Principle）

開閉原則就是說對擴展開放，對修改關閉。在程序需要進行拓展的時候，不能去修改原有的代碼，實現一個熱插拔的效果。

2、裏氏代換原則（Liskov Substitution Principle）

其官方描述比較抽象，可自行百度。實際上可以這樣理解：（1）子類的能力必須大於等於父類，即父類可以使用的方法，子類都可以使用。（2）返回值也是同樣的道理。假設一個父類方法返回一個List，子類返回一個ArrayList，這當然可以。如果父類方法返回一個ArrayList，子類返回一個List，就說不通了。這裏子類返回值的能力是比父類小的。（3）還有拋出異常的情況。任何子類方法可以聲明拋出父類方法聲明異常的子類。
而不能聲明拋出父類沒有聲明的異常。

3、依賴倒轉原則（Dependence Inversion Principle）

這個是開閉原則的基礎，具體內容：面向接口編程，依賴於抽象而不依賴於具體。

4、接口隔離原則（Interface Segregation Principle）

這個原則的意思是：使用多個隔離的接口，比使用單個接口要好。還是一個降低類之間的耦合度的意思，從這兒我們看出，其實設計模式就是一個軟件的設計思想，從大型軟件架構出發，為了升級和維護方便。所以上文中多次出現：降低依賴，降低耦合。

5、迪米特法則（最少知道原則）（Demeter Principle）

為什麽叫最少知道原則，就是說：一個實體應當盡量少的與其他實體之間發生相互作用，使得系統功能模塊相對獨立。

6、合成復用原則（Composite Reuse Principle）

原則是盡量使用合成/聚合的方式，而不是使用繼承。

三、創建型模式

創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

3.1、工廠方法模式

工廠方法模式分為三種：普通工廠模式、多個工廠方法模式和靜態工廠方法模式。

3.1.1、普通工廠模式

普通工廠模式就是建立一個工廠類，對實現了同一接口的一些類進行實例的創建。

package com.mode.create;

public interface MyInterface {
    public void print();
}
  • 1
  • 2
  • 3
  • 4
  • 5
package com.mode.create;

public class MyClassOne implements MyInterface {

    @Override
    public void print() {
        System.out.println("MyClassOne");
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
package com.mode.create;

public class MyClassTwo implements MyInterface {

    @Override
    public void print() {
        System.out.println("MyClassTwo");
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

“`
package com.mode.create;

public class MyFactory {

public MyInterface produce(String type) {  
    if ("One".equals(type)) {  
        return new MyClassOne();  
    } else if ("Two".equals(type)) {  
        return new MyClassTwo();  
    } else {  
        System.out.println("沒有要找的類型");  
        return null;  
    }  
}

}


package com.mode.create;

public class FactoryTest {

public static void main(String[] args){
    MyFactory factory = new MyFactory();  
    MyInterface myi = factory.produce("One");  
    myi.print();
}

}
“`
FactoryTest的運行結果我想應該很明顯了。

再回頭來理解這句話：普通工廠模式就是建立一個工廠類，對實現了同一接口的一些類進行實例的創建。

3.1.2、多個工廠方法模式

多個工廠方法模式，是對普通工廠方法模式的改進，多個工廠方法模式就是提供多個工廠方法，分別創建對象。

直接看代碼吧，我們修改MyFactory和FactoryTest如下：

package com.mode.create;

public class MyFactory {

    public MyInterface produceOne() {
        return new MyClassOne();
    }

    public MyInterface produceTwo() {
        return new MyClassTwo();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){
        MyFactory factory = new MyFactory();  
        MyInterface myi = factory.produceOne();
        myi.print();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

運行結果也是十分明顯了。

再回頭來理解這句話：多個工廠方法模式，是對普通工廠方法模式的改進，多個工廠方法模式就是提供多個工廠方法，分別創建對象。

3.1.3、靜態工廠方法模式

靜態工廠方法模式，將上面的多個工廠方法模式裏的方法置為靜態的，不需要創建實例，直接調用即可。

直接看代碼吧，我們修改MyFactory和FactoryTest如下：

package com.mode.create;

public class MyFactory {

    public static MyInterface produceOne() {
        return new MyClassOne();
    }

    public static MyInterface produceTwo() {
        return new MyClassTwo();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){ 
        MyInterface myi = MyFactory.produceOne();
        myi.print();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

運行結果依舊很明顯。

再回顧：靜態工廠方法模式，將上面的多個工廠方法模式裏的方法置為靜態的，不需要創建實例，直接調用即可。

3.2、抽象工廠模式

工廠方法模式有一個問題就是，類的創建依賴工廠類，也就是說，如果想要拓展程序，必須對工廠類進行修改，這違背了閉包原則。

為解決這個問題，我們來看看抽象工廠模式：創建多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的代碼。

這樣就符合閉包原則了。

下面來看看代碼：

MyInterface、MyClassOne、MyClassTwo不變。

新增如下接口和類：

package com.mode.create;

public interface Provider {
    public MyInterface produce(); 
}
  • 1
  • 2
  • 3
  • 4
  • 5
package com.mode.create;

public class MyFactoryOne implements Provider {

    @Override
    public MyInterface produce() {
        return new MyClassOne();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
package com.mode.create;

public class MyFactoryTwo implements Provider {

    @Override
    public MyInterface produce() {
        return new MyClassTwo();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

修改測試類FactoryTest如下：

package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){ 
        Provider provider = new MyFactoryOne();
        MyInterface myi = provider.produce();
        myi.print();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

運行結果依舊顯然。

再回顧：抽象工廠模式就是創建多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的代碼。

3.3、單例模式

單例模式，不需要過多的解釋。

直接看代碼吧：

package test;

public class MyObject {

    private static MyObject myObject;

    private MyObject() {
    }

    public static MyObject getInstance() {
        if (myObject != null) {
        } else {
            myObject = new MyObject();
        }
        return myObject;
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

但是這樣會引發多線程問題，詳細解說可以看《Java多線程編程核心技術》書中的第六章。博主之前推薦過這本書，裏面有電子完整版下載地址：http://blog.csdn.net/u013142781/article/details/50805655

3.4、建造者模式

建造者模式：是將一個復雜的對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

字面看來非常抽象，實際上它也十分抽象！！！！

建造者模式通常包括下面幾個角色：

（1） Builder：給出一個抽象接口，以規範產品對象的各個組成成分的建造。這個接口規定要實現復雜對象的哪些部分的創建，並不涉及具體的對象部件的創建。

（2） ConcreteBuilder：實現Builder接口，針對不同的商業邏輯，具體化復雜對象的各部分的創建。 在建造過程完成後，提供產品的實例。

（3）Director：調用具體建造者來創建復雜對象的各個部分，在指導者中不涉及具體產品的信息，只負責保證對象各部分完整創建或按某種順序創建。

（4）Product：要創建的復雜對象。

在遊戲開發中建造小人是經常的事了，要求是：小人必須包括頭，身體和腳。

下面我們看看如下代碼：

Product（要創建的復雜對象。）：

package com.mode.create;

public class Person {

    private String head;
    private String body;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}
  • 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

Builder（給出一個抽象接口，以規範產品對象的各個組成成分的建造。這個接口規定要實現復雜對象的哪些部分的創建，並不涉及具體的對象部件的創建。）：

package com.mode.create;

public interface PersonBuilder {
    void buildHead();
    void buildBody();
    void buildFoot();
    Person buildPerson();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

ConcreteBuilder（實現Builder接口，針對不同的商業邏輯，具體化復雜對象的各部分的創建。 在建造過程完成後，提供產品的實例。）：

package com.mode.create;

public class ManBuilder implements PersonBuilder {

    Person person;

    public ManBuilder() {
        person = new Person();
    }

    public void buildBody() {
        person.setBody("建造男人的身體");
    }

    public void buildFoot() {
        person.setFoot("建造男人的腳");
    }

    public void buildHead() {
        person.setHead("建造男人的頭");
    }

    public Person buildPerson() {
        return person;
    }

}
  • 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

Director（調用具體建造者來創建復雜對象的各個部分，在指導者中不涉及具體產品的信息，只負責保證對象各部分完整創建或按某種順序創建。）：

package com.mode.create;

public class PersonDirector {
    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

測試類：

package com.mode.create;

public class Test {
    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

運行結果：
技術分享圖片
回顧：建造者模式：是將一個復雜的對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

3.5、原型模式

該模式的思想就是將一個對象作為原型，對其進行復制、克隆，產生一個和原對象類似的新對象。

說道復制對象，我將結合對象的淺復制和深復制來說一下，首先需要了解對象深、淺復制的概念：

淺復制：將一個對象復制後，基本數據類型的變量都會重新創建，而引用類型，指向的還是原對象所指向的。
深復制：將一個對象復制後，不論是基本數據類型還有引用類型，都是重新創建的。簡單來說，就是深復制進行了完全徹底的復制，而淺復制不徹底。

寫一個深淺復制的例子：

package com.mode.create;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Prototype implements Cloneable, Serializable {

    private static final long serialVersionUID = 1L;

    private int base;

    private Integer obj;

     /* 淺復制 */  
    public Object clone() throws CloneNotSupportedException {
        // 因為Cloneable接口是個空接口，你可以任意定義實現類的方法名
        // 如cloneA或者cloneB，因為此處的重點是super.clone()這句話
        // super.clone()調用的是Object的clone()方法
        // 而在Object類中，clone()是native（本地方法）的
        Prototype proto = (Prototype) super.clone();
        return proto;
    }

    /* 深復制 */
    public Object deepClone() throws IOException, ClassNotFoundException {

        /* 寫入當前對象的二進制流 */
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        /* 讀出二進制流產生的新對象 */
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

    public int getBase() {
        return base;
    }

    public void setBase(int base) {
        this.base = base;
    }

    public Integer getObj() {
        return obj;
    }

    public void setObj(Integer obj) {
        this.obj = obj;
    }

}
  • 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
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

測試類：

package com.mode.create;

import java.io.IOException;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException,
            ClassNotFoundException, IOException {
        Prototype prototype = new Prototype();
        prototype.setBase(1);
        prototype.setObj(new Integer(2));
        /* 淺復制 */ 
        Prototype prototype1 = (Prototype) prototype.clone();
        /* 深復制 */
        Prototype prototype2 = (Prototype) prototype.deepClone();
        System.out.println(prototype1.getObj()==prototype1.getObj());
        System.out.println(prototype1.getObj()==prototype2.getObj());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

運行結果：
技術分享圖片

Java設計模式之五大創建型模式（附實例和詳解）

相關推薦

Java設計模式之五大創建型模式（附實例和詳解）

caf aac concrete 為什麽 ota pil sem 而不是 rtm 一、概況 總體來說設計模式分為三大類： （1）創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 （2）結構型模式，共七種：適配器模式、裝飾器模式、代理模式

C#設計模式之五創建者模式（Builder）【創建型】

包含 direct linq 自然 解釋 並且 宋體 主板 但是 一、引言 今天我們要講講Builder模式，也就是建造者模式，當然也有叫生成器模式的。在現實生活中，我們經常會遇到一些構成比較復雜的物品，比如：電腦，它就是一個復雜的物品，它主要是由CPU、主板、硬盤、顯卡

單件模式-- 5種創建型模式之一

cpp 一個 cnblogs logs on() int include gets urn 保證一個類只有一個實例 # include <iostream> class Singleton { public: static Singleton

Socket程式設計之TCP例項（附C/C++程式碼詳解）

說明： 主要分步驟給出Windows平臺下socket程式設計的一個TCP例項；使用WINDOWS下網路程式設計規範Winsock完成網路通訊； 對程式各部分細節進行描述。 套接字有三種傳輸型別SOCK_STREAM    SOCK_DGRAM   SOCK_RAW；

Java設計模式（8）——創建型模式之合成（組合）模式

span color java設計 合成 src 一致性 rdquo img spa 一、概述 　　定義 　　將對象以樹形結構組織起來，以達成“部分－整體” 的層次結構，使得客戶端對單個對象和組合對象的使用具有一致性。 　　簡圖 　　 J

Java設計模式（9）——創建型模式之裝飾模式

block 擴展 str 分享 增加 image tro col 技術 一、概述 　　動態地給一個對象添加一些額外的職責。就增加功能來說， Decorator模式相比生成子類更為靈活。該模式以對客 戶端透明的方式擴展對象的功能。 　　UML簡圖 　　 　　角

一起來學設計模式-----創建型模式之工廠方法

定義 修改 microsoft png ont 其他 urn 設計模式 cto 工廠方法模式，在簡單工廠上再深一層，簡單工廠裏有一個弊端，就是在方法裏是根據用戶的輸入直接返回子類對象。在工廠方法裏，定義了一個用於創建對象的接口，讓子類決定實例化哪一個類，工廠方

設計模式之創建型模式

餓漢式 abs TE 另一個 時也 解釋 自己 alt hat 好長時間沒有寫博客了，今天看了創建型設計模式，做個簡單的總結 　　創建型模式 　　　　這種類型的設計模式提供了一種在創建對象的同時隱藏創建邏輯。包含工廠模式（Factory Pattern）抽象工廠模式（Abs

（轉自精通Python設計模式）Python設計模式之創建型模式——2.建造者模式

生成 需要 結構 progress per 展示 有意 odi con 　　建造者模式將一個復雜對象的構造過程與其表現分離，這樣，同一個構造過程可用於創建多個不同的表現。 　　我們來看個實際的例子，假設我們想要創建一個HMTL頁面生成器，HTML頁面的基本結構（構造組件）

淺析設計模式（七）——創建型模式之Builder(建造者模式)

main方法 ref 內部 spa implement line pat 接口 及其 建造者模式Builder 本文的內容： 一、建造者模式的定義 二、建造者模式的參與者及其角色 三、建造者模式的類圖 四、建造者模式的示例 五、參考 一、建造者模式的定義 　　 將一個復

淺析設計模式（八）——創建型模式之Prototype(原型模式)

ref rri head 創建型模式 obj www str 操作 接口 原型模式Prototype 本文的內容： 一、原型模式的定義 二、原型模式的參與者及其角色 三、原型模式的類圖 四、原型模式的示例 五、參考 一、原型模式的定義 　　定義：用原型

Java經典設計模式之五大建立型模式（附例項和詳解）

一、概況 總體來說設計模式分為三大類： （1）建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 （2）結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。 （3）行為型模式，共十一

轉載-------Java經典設計模式之五大建立型模式（附例項和詳解）

一、概況 總體來說設計模式分為三大類： （1）建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 （2）結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。 （3）行為型模式

【設計模式】創建型模式之抽象工廠模式（四）

庫類 修改 create 配置 esp 指定 ase sse 種類 抽象工廠模式 提供一個創建一系列相關或相互依賴對象的接口，而無需指定他們的具體的類。 【為創建不同的產品對象，客戶端應使用不同的具體工廠】 通俗理解：我們可以理解成：一臺電腦。最基本的配件：CPU、

23種設計模式介紹（一）---- 創建型模式

接口 ret static 深復制 return 對象 相互 object c png 由於設計模式篇幅比較大，如果在一篇文章講完所有的設計模式的話不利於閱讀。於是我把它分為三篇文章 23種設計模式介紹（一）---- 創建型模式 23種設計模式介紹（二）---- 結構型模

設計模式——創建型模式分析

設計模式 創建型模式設計模式——創建型模式分析 創建型模式(Creational Pattern)對類的實例化過程進行了抽象，能夠將軟件模塊中對象的創建和對象的使用分離。為了使軟件的結構更加清晰，外界對於對象只需要知道共同的接口即可，而不需要清楚其具體的實現細節，使整個系統的設計更加符合單一職責原則。

《大話設計模式》筆記(1)——創建型模式

原型模式 優點 sta oracle數據 () 生成器模式 ret singleton 生成器 1、簡單工廠模式/靜態工廠方法 　　定義：簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。 　　UML： 　　PS：這個設計模式太簡單了，沒什麽好解說的，簡單來說

創建型模式之 抽象工廠模式

實現類 blog 教程 例子 UC 生成器 factory 生成 ... 介紹參見菜鳥教程 下面給出C++的一個例子 #include<iostream> #include<memory> using namespace std; //shap接

設計模式- 創建型模式， 建造者模式(2)

wait 設計模式 部件 add put AD progress port http java23種設計模式之一，英文叫Builder Pattern。其核心思想是將一個“復雜對象的構建算法”與它的“部件及組裝方式”分離，使得

設計模式_創建型模式_簡單工廠模式

9.png 類對象 代碼 客戶 調用 例如 src static ron 轉載自：http://blog.csdn.net/lovelion 作者：劉偉 簡單工廠模式並不屬於GoF 23個經典設計模式，但通常將它作為學習其他工廠模式的基礎，它的設計思想很簡單，其基本流