2. 程式人生 > >程式設計設計模式 -- （工廠設計）

程式設計設計模式 -- （工廠設計）

阿新 • • 發佈：2018-12-10

一 、工廠設計模式

需求 : 舉辦晚會.

開始 : 晚會開始了…
節目1 : 劉德華演唱 <冰雨> 歌曲 …
節目2 : 少女時代跳 <Gee Gee Gee> 舞曲 …
節目3 : 趙本山表演 <賣柺> 節目 …
結束 : 晚會太棒了, 難忘今宵…

實現一 : 面向列印程式設計

public class EveningParty {
    public static void main(String[] args) {
        System.out.println("開始 : 晚會開始了…");
        System.out
 
.println("節目1 : 劉德華演唱 <冰雨> 歌曲 …");
        System.out.println("節目2 : 少女時代跳 <Gee Gee Gee> 舞曲 …");
        System.out.println("節目3 : 趙本山表演 <賣柺> 節目 …");
        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

這裡寫圖片描述

實現二 : 面向物件程式設計

準備資料：

LiuDeHua類

public class LiuDeHua  {

    public
 
 void sing() {
        System.out.println("節目1 : 劉德華演唱 <冰雨> 歌曲 …");
    }
}

GirlsGeneration類

public class GirlsGeneration  {

    public void dance() {
        System.out.println("節目2 : 少女時代跳 <Gee Gee Gee> 舞曲 …");
    }
}

ZhaoBenShan類

public class ZhaoBenShan  {

    public void perform
 
() {
        System.out.println("節目3 : 趙本山表演 <賣柺> 節目 …");
    }
}

實現程式碼

public class EveningParty {
    public static void main(String[] args) {

        System.out.println("開始 : 晚會開始了…");

        // 1. 建立一個 `劉德華` 物件
        LiuDeHua liuDeHua = new LiuDeHua();
        liuDeHua.sing();

        // 2. 建立一個 `少女時代` 物件
        GirlsGeneration girls = new GirlsGeneration();
        girls.dance();

        // 3. 建立一個 `趙本山` 物件
        ZhaoBenShan zhaoBenShan = new ZhaoBenShan();
        zhaoBenShan.perform();

        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

這裡寫圖片描述

現在，劉德華通告滿了來不了，怎麼辦？請張學友唱歌也可以啊。少女時代解散了不能來跳舞了，怎麼辦？我請少女團伙過來。本山大叔不來演小品了，我請劉謙來變魔術吧。

ZhangXueYou類

public class ZhangXueYou {

    public void sing() {
        System.out.println("節目1 : 張學友演唱 <一路上有你> 歌曲...");
    }
}

GirlsTeam類

public class GirlsTeam {

    public void dance() {
        System.out.println("節目2 : 少女團伙跳 <京東不太熱> 舞曲...");
    }
}

LiuQian類

public class LiuQian  {

    public void perform() {
        System.out.println("節目3 : 劉謙表演 <大變死人> 節目...");
    }
}

程式碼實現

public class EveningParty {
    public static void main(String[] args) {

        System.out.println("開始 : 晚會開始了…");

        // 1. 建立一個 `張學友` 物件
        ZhangXueYou zhangXueYou = new ZhangXueYou();
        zhangXueYou.sing();

        // 2. 建立一個 `少女時代` 物件
        GirlsTeam girls = new GirlsTeam();
        girls.dance();

        // 3. 建立一個 `劉謙` 物件
        LiuQian liuQian = new LiuQian();
        liuQian.perform();

        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

實現三 : 面向介面程式設計

我們發現了，需求是舉辦舞會，表演節目是誰我不管，只要晚會舉行了就好。 要唱歌的就來一個唱歌的、要跳舞的就來一個跳舞的、要表演的就來一個會表演的就行。 所以我們可以讓物件實現介面來繼續。

需求 : 舉辦晚會.

開始 : 晚會開始了…
節目1 : 劉德華演唱 <冰雨> 歌曲 …                     找一個唱歌的.
節目2 : 少女時代跳 <Gee Gee Gee> 舞曲 …              找一個跳舞的.
節目3 : 趙本山表演 <賣柺> 節目 …                     找一個表演的.
結束 : 晚會太棒了, 難忘今宵…

Singable 介面

public interface Singable {
    void sing();
}

Dancable 介面

public interface Dancable {
    void dance();
}

Performable 介面

public interface Performable {
    void perform();
}

讓LiuDeHua、ZhangXueYou實現Singable 介面；

public class LiuDeHua implements Singable {

    @Override
    public void sing() {
        System.out.println("節目1 : 劉德華演唱 <冰雨> 歌曲 …");
    }
}
public class ZhangXueYou implements Singable {

    @Override
    public void sing() {
        System.out.println("節目1 : 張學友演唱 <一路上有你> 歌曲...");
    }
}
GirlsGeneration、GirlsTeam實現 Dancable 介面

public class GirlsGeneration implements Dancable {

@Override
public void dance() {
    System.out.println("節目2 : 少女時代跳 <Gee Gee Gee> 舞曲 …");
}

}

public class GirlsTeam implements Dancable {

    @Override
    public void dance() {
        System.out.println("節目2 : 少女團伙跳 <京東不太熱> 舞曲...");
    }
}

ZhaoBenShan、LiuQian實現 Performable 介面

public class ZhaoBenShan implements Performable {

    @Override
    public void perform() {
        System.out.println("節目3 : 趙本山表演 <賣柺> 節目 …");
    }
}
public class LiuQian implements Performable {

    @Override
    public void perform() {
        System.out.println("節目3 : 劉謙表演 <大變死人> 節目...");
    }
}

實現程式碼：

public class EveningParty {
    public static void main(String[] args) {

        System.out.println("開始 : 晚會開始了…");

        // 1. 建立一個 `張學友` 物件
        Singable s = new ZhangXueYou();
        s.sing();

        // 2. 建立一個 `少女團伙` 物件
        Dancable d = new GirlsTeam();
        d.dance();

        // 3. 建立一個 `劉謙` 物件
        Performable p = new LiuQian();
        p.perform();

        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

public class EveningParty {
    public static void main(String[] args) {

        System.out.println("開始 : 晚會開始了…");

        // 1. 建立一個 `劉德華` 物件
        Singable s = new LiuDeHua();
        s.sing();

        // 2. 建立一個 `少女時代` 物件
        Dancable d = new GirlsGeneration();
        d.dance();

        // 3. 建立一個 `趙本山` 物件
        Performable p = new ZhaoBenShan();
        p.perform();

        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

實現四 : 工廠設計模式程式設計 換人的流程好像變簡單了。 但是，我的主業務邏輯是舉辦晚會, 到底來誰, 不重要. 那麼為什麼每次換人時, 我的主業務邏輯都需要不停修改呢 ???。 我們應該將晚會需要的 物件 交給一個獨立的類提供. 這個類就被稱為 晚會工廠類. PartyFactory. 作用: 為主業務邏輯提供需要的物件. 這樣就實現了，我的主業務邏輯不變，需要的物件由晚會的工廠類來實現。

// 工廠設計模式 : 配置檔案 + 反射

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class PartyFactory {
    // 屬性
    private static final Properties prop;

    // 靜態程式碼塊
    static {
        prop = new Properties();

        try {
            prop.load(new FileReader("party.properties"));
        } catch (IOException e) {
            throw new RuntimeException("配置檔案載入失敗!");
        }
    }

    public static Singable getSingable() {
        // 1. 根據 key 獲取 prop 物件中的 value
        String className = prop.getProperty("Singable");
        try {
            // 2. 反射建立物件
            Class<?> cls = Class.forName(className);
            Object o = cls.getDeclaredConstructor().newInstance();

            // 3. 強轉, 並返回
            return (Singable) o;
        } catch (Exception e) {
            throw new RuntimeException("物件建立失敗!");
        }
    }

    public static Dancable getDancable() {
        // 1. 根據 key 獲取 prop 物件中的 value
        String className = prop.getProperty("Dancable");
        try {
            // 2. 反射建立物件
            Class<?> cls = Class.forName(className);
            Object o = cls.getDeclaredConstructor().newInstance();

            // 3. 強轉, 並返回
            return (Dancable) o;
        } catch (Exception e) {
            throw new RuntimeException("物件建立失敗!");
        }
    }

    public static Performable getPerformable() {
        // 1. 根據 key 獲取 prop 物件中的 value
        String className = prop.getProperty("Performable");
        try {
            // 2. 反射建立物件
            Class<?> cls = Class.forName(className);
            Object o = cls.getDeclaredConstructor().newInstance();

            // 3. 強轉, 並返回
            return (Performable) o;
        } catch (Exception e) {
            throw new RuntimeException("物件建立失敗!");
        }
    }
}

配置檔案 : party.properties

#Singable=cn.itcast.party.LiuDeHua
#Dancable=cn.itcast.party.GirlsGeneration
#Performable=cn.itcast.party.ZhaoBenShan

Singable=cn.itcast.party.ZhangXueYou
Dancable=cn.itcast.party.GirlsTeam
Performable=cn.itcast.party.LiuQian

實現程式碼：

public class EveningParty {
    public static void main(String[] args) {

        System.out.println("開始 : 晚會開始了…");

        // 1. 晚會工廠類, 給我來一個會唱歌的.
        Singable s = PartyFactory.getSingable();
        s.sing();

        // 2. 晚會工廠類, 給我來一個會跳舞的.
        Dancable d = PartyFactory.getDancable();
        d.dance();

        // 3. 晚會工廠類, 給我來一個會表演的.
        Performable p = PartyFactory.getPerformable();
        p.perform();

        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

party.properties就像是晚會表演名單一樣，我只管提需求，而真正幹活的是承辦者也就是晚會工廠類,我不管你給我什麼，我只要晚會能順利舉行就好，這就是設計過程中的 Factorty 設計模式。

實現五 : 工廠設計程式設計優化方案

// 工廠設計模式 : 配置檔案 + 反射

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class PartyFactory {
    // 屬性
    private static final Properties prop;

    // 靜態程式碼塊
    static {
        prop = new Properties();

        try {
            prop.load(new FileReader("party.properties"));
        } catch (IOException e) {
            throw new RuntimeException("配置檔案載入失敗!");
        }
    }

    public static <T> T getInstance(Class<T> cls) {
        // 0. 獲取 key
        String key = cls.getSimpleName();

        // 1. 根據 key 獲取 prop 物件中的 value
        String className = prop.getProperty(key);
        try {
            // 2. 反射建立物件
            Class<?> c = Class.forName(className);
            Object o = c.getDeclaredConstructor().newInstance();

            // 3. 強轉, 並返回
            return (T) o;
        } catch (Exception e) {
            throw new RuntimeException("物件建立失敗!");
        }
    }
}

通過反射將程式碼設計的更加簡潔。

配置檔案 : party.properties

#Singable=cn.itcast.party.LiuDeHua
#Dancable=cn.itcast.party.GirlsGeneration
#Performable=cn.itcast.party.ZhaoBenShan

Singable=cn.itcast.party.ZhangXueYou
Dancable=cn.itcast.party.GirlsTeam
Performable=cn.itcast.party.LiuQian

實現程式碼：

public class EveningParty {
    public static void main(String[] args) {

        System.out.println("開始 : 晚會開始了…");

        // 1. 晚會工廠類, 給我來一個會唱歌的.
        Singable s = PartyFactory.getSingable();
        s.sing();

        // 2. 晚會工廠類, 給我來一個會跳舞的.
        Dancable d = PartyFactory.getDancable();
        d.dance();

        // 3. 晚會工廠類, 給我來一個會表演的.
        Performable p = PartyFactory.getPerformable();
        p.perform();

        System.out.println("結束 : 晚會太棒了, 難忘今宵…");
    }
}

執行程式，結果都是下面兩種的一種，但是不管哪一種都實現了我舉辦晚會的需求。

結果1：

這裡寫圖片描述

結果2：

這裡寫圖片描述

工廠設計模式總結

工廠設計模式是一種強調結果而不在乎過程的設計模式。

相關推薦

程式設計設計模式 -- （工廠設計）

一 、工廠設計模式 需求 : 舉辦晚會. 開始 : 晚會開始了… 節目1 : 劉德華演唱 <冰雨> 歌曲 … 節目2 : 少女時代跳 <Gee Gee Gee> 舞曲 … 節目3 : 趙本山表演 <賣柺> 節目 … 結束

創建型設計模式（工廠模式）

ava lsi else if 接口 spa 模式 cas 並且 return 在工廠模式中，我們創建對象而不將創建邏輯暴露給客戶端。 首先，我們設計一個接口來表示Shape。 public interface Shape { void draw(); } 然後

javaScript設計模式---（工廠模式學習）

新的 創建對象 cto ret 我們 接口 ceo .proto run 工廠模式(Factory)提供一個公用的接口來創建對象。 如有一個UI庫，我們要創建某個UI組件的類型，不需要直接使用new 運算符或者通過另一個創建型構造函數創建這個組件，而是要求Factory對象

初識設計模式（工廠模式 總）

不同的 www. 集合 拓展 繼承 開放 操作符 創建 必須 前言：繼續學習設計模式，前面學習了策略模式、觀察者模式、裝飾者模式，今天學習工廠模式。除了使用 new 操作符之外，還有更多制造對象的方法，比如下面講到的簡答工廠模式、工廠方法模式、抽象方法模式。轉載請註明出處

設計模式(9)----- 補充spring中的工廠設計模式（手寫）

package com.DesignPatterns.ad.factory6; public interface BeanFactory { Object getBean(String id); }     package com.DesignPattern

JAVA 23種設計設計模式---工廠模式（工廠方法）

設計模式中的工廠模式可大致分為3個，簡單工廠、工廠方法、抽象工廠。 今天整理的是工廠方法模式，介紹如下： 案列結構如下： 程式碼結構如下：   卡車： package com.zxf.method; //卡車(介面) public interfac

C語言和設計模式（工廠模式）

                【 宣告：版權所有，歡迎轉載，請勿用於商業用途。  聯絡信箱：feixiaoxing @163.com】    工廠模式是比較簡單，也是比較好用的一種方式。根本上說，工廠模式的目的就根據不同的要求輸出不同的產品。比如說吧，有一個生產鞋子的工廠，它能生產皮鞋，也能生產膠鞋。如果用

【JAVA】基礎：設計模式（單例設計模式，工廠設計模式）

設計模式：解決某一類問題最行之有效的方法。 java中有23種設計模式。 建立型模式（5種）：工廠方法模式，抽象工廠模式，單例模式，建造者模式，原型模式。 結構型模式（7種）：介面卡模式，裝飾器模式，代理模式，外觀模式，橋接模式，組合模式，享元模式。 行為型模式（11種）：策略模式、模板方法

建立類設計模式（5種）——工廠類相關模式

建立類設計模式（5種）——工廠類相關模式 一、快餐點餐系統 想必大家一定見過類似於麥當勞自助點餐檯一類的點餐系統吧。在一個大的觸控顯示屏上，有三類可以選擇的上餐品：漢堡等主餐、小食、飲料。當我們選擇好自己需要的食物，支付完成後，訂單就生成了。下面，我們用今天的主角--工廠模式--來生成這些食

Gof23種設計模式+簡單工廠設計模式總結（一）

一、軟體設計模式的種類 1.建立型模式 如何建立物件 2.結構型模式 如何實現類和物件的組合 3.行為型模式 類和物件怎麼樣互動以及怎麼樣分配職責 二、設計模式的原則 高內聚、低耦合 1.單一職責原則 類的職責比較

大戰設計模式（第二季）【1】———— 從源碼看工廠模式

new map 下一個 建議 mage 管理 增長 如果 per 前言 工廠模式其實在許多地方都有體現，是常見的一種設計模式。用一句話總結就是，當我們需要創建一些對象的時候，而創建的對象比較復雜或者同類型比較多，就可以使用它。 在我們看源碼的時候，有的時候看見XXXFa

Java設計模式（工廠模式）

  一．簡單工廠模式 　　簡單工廠模式就是把對類的建立初始化全都交給一個工廠來執行，而使用者不需要去關心建立的過程是什麼樣的，只用告訴工廠我想要什麼就行了。而這種方法的缺點也很明顯，違背了設計模式的開閉原則，因為如果你要增加工廠可以初始化的類的時候，你必須對工廠進行改建 程式碼如下： p

設計模式（Java語言）- 簡單工廠模式

　　簡單工廠模式有稱為靜態工廠模式，屬於設計模式中的建立型模式。簡單工廠模式通過對外提供一個靜態方法來統一為類建立例項。簡單工廠模式的目的是實現類與類之間解耦，其次是客戶端不需要知道這個物件是如何被穿創建出來的，只需要呼叫簡單工廠模式的方法來統一建立就可以了，從而明確了各個類的職責。 　　一、建立簡單工廠模式

Qt MVC設計模式（五篇）

net details blog 模式 mvc設計模式 sdn .net 設計 mvc http://blog.csdn.net/qq_19672579/article/details/46952675http://blog.csdn.net/qq_19672579/art

設計模式（十七）---策略模式

封裝 客戶端 else 互換 rip oid 接口 相同 角色 1、簡介 　　策略模式屬於對象的行為模式。其用意是針對一組算法，將每一個算法封裝到具有共同接口的獨立的類中，從而使得它們可以相互替換。策略模式使得算法可以在不影響到客戶端的情況下發生變化。 2、策略模式的結構

設計模式（十八）---模板方法模式

strac string package style prim res 不同的 好的 clas 1、簡介 　　模板方法模式是類的行為模式。準備一個抽象類，將部分邏輯以具體方法以及具體構造函數的形式實現，然後聲明一些抽象方法來迫使子類實現剩余的邏輯。 　　不同的子類可以以不同

解讀GoF的23鐘設計模式（濃縮版）

style ref gof shuf blank gin qtp tns com 2MIU5P075E促http://jz.docin.com/sina_5848269111 7r奔1C5IY航椅5http://shequ.docin.com/sina_6270047027

設計模式（十八）——職責鏈模式

設計模式 職責鏈模式設計模式（十八）——職責鏈模式一、職責鏈模式簡介1、職責鏈模式簡介職責鏈模式（Chain Of Responsibility）使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合。將可能處理請求的對象連成一條鏈，並沿著這條鏈傳遞請求，直到有一個對象處理請求為止。2、職責連模式

設計模式（二十）——備忘錄模式

設計模式 備忘錄模式設計模式（二十）——備忘錄模式一、備忘錄模式1、備忘錄模式簡介 備忘錄模式在不破壞封裝性的前提下，捕獲一個對象的內部狀態，並在對象之外保存這個狀態，以後就可將對象恢復到原先保存的狀態。2、備忘錄模式角色 發起人Originator：負責創建一個Memento，用以記錄當前時刻O

設計模式（二十三）——中介者模式

設計模式 中介者模式設計模式（二十三）——中介者模式一、中介者模式簡介1、中介者模式簡介 中介者模式用一個中介對象來封裝一系列的對象交互。中介者使各對象不需要顯式地相互引用，從而使其耦合松散，而且可以獨立地改變它們之間的交互。 中介者模式中，每個同事對象維護一個中介者，當要進行通信時，每個具體的同