2. 程式人生 > >設計模式——工廠方法 Java原始碼

設計模式——工廠方法 Java原始碼

阿新 • • 發佈：2019-01-06

本程式改編自《Head First Design Patterns》中的Pizza例子，我本學期早上經常吃包子。

總共有11個類：

  • 一個工廠父類 ( Creator)
  • 兩個工廠子類 ( Concrete Creator)
  • 一個包子父類 ( Product )
  • 六個包子子類 ( Concrete Product )
  • 一個Main類 ( 程式的入口 )

工廠模式
圖：ConcreteProduct 繼承 Product，ConcreteCreator 繼承 Creator，ConcreateProduct 依賴 ConcreateProduct。其實，有一條線沒有顯示出來：Creator 依賴 Product。

Head First 說，這體現了依賴倒置原則：因為高層模組（Creator）依賴抽象類（Product），底層模組（ConcreteProduct）也依賴抽象類（Product）。

補充說明：我個人感覺，嚴格的說：ConcreteProduct 和Product 之間不是依賴，而是繼承關係。勉強說的話，算作一種”非常非常強的依賴“吧。Head First : The ConcreteProduct class depends on the Product abstraction too, because they implement the Product interface (we’re using the “interface” in the general sense) in the Product abstraction class.

一個工廠父類

package factoryMethod;

public abstract class BaoZiFactory {

    // 把具體的 new操作 “下放”到子類中。
    abstract BaoZi createBaoZi(String baoZiName);

    // 這個方法不改變，即無論包子裡面的餡是什麼，製作包子的流程是一樣的（都是準備餡，然後蒸30分鐘）
    final public BaoZi makeBaoZi(String baoZiName)
    {
        BaoZi baoZi = createBaoZi(baoZiName);
        baoZi.prepare();
        baoZi.steam();

        return
 
 baoZi;
    }
}

兩個工廠子類

package factoryMethod;

public class BaoZiFactoryChangsha extends BaoZiFactory {

    public BaoZiFactoryChangsha() 
    {
        System.out.println("Constructor of BaoZiFactory in Changsha\n");
    }

    @Override // 依據傳進來的引數，決定new什麼包子
    BaoZi createBaoZi(String baoZiName)
    {
        BaoZi baoZi = null;
        if(baoZiName.equals("醬肉"))
        {
            baoZi = new ChangshaJiangRouBaoZi();
        }
        else if(baoZiName.equals("青菜"))
        {
            baoZi = new ChangshaQingCaiBaoZi();
        }
        else if(baoZiName.equals("鮮肉"))
        {
            baoZi = new ChangshaXianRouBaoZi();
        }
        return baoZi;
    }

}

package factoryMethod;

public class BaoZiFactoryWuhan extends BaoZiFactory {

    public BaoZiFactoryWuhan() 
    {
        System.out.println("Constructor of BaoZiFactory in Wuhan\n");
    }

    @Override // 依據傳進來的引數，決定new什麼包子
    BaoZi createBaoZi(String baoZiName) 
    {
        BaoZi baoZi = null;
        if(baoZiName.equals("醬肉"))
        {
            baoZi = new WuhanJiangRouBaoZi();
        }
        else if(baoZiName.equals("青菜"))
        {
            baoZi = new WuhanQingCaiBaoZi();
        }
        else if(baoZiName.equals("鮮肉"))
        {
            baoZi = new WuhanXianRouBaoZi();
        }
        return baoZi;
    }

}

一個包子父類

package factoryMethod;

import java.util.ArrayList;

// 父類：包子，抽象出包子共有的特性
// 有道詞典：steamed stuffed bun （蒸的，填充的，小圓麵包）
// 由於這三個單詞加起來過長，我命名放棄採納英文命名法，直接使用漢語拼音命名法BaoZi
public abstract class BaoZi {
    private String name;
    ArrayList<String> stuffings = new ArrayList<String> ();

    public void setName(String n)
    {
        this.name = n;
    }
    public String getName()
    {
        return name;
    }
    void prepare()
    {
        System.out.println("Prepare " + name);
        System.out.println("Stuffings are:");
        for(String stuff: stuffings)
        {
            System.out.println(stuff);
        }
    }

    void steam()
    {
        System.out.println("Steam for 30 minutes");
    }

    //覆蓋toString (這個方法繼承自java.lang.Object)
    public String toString()
    {
        StringBuffer display = new StringBuffer();
        display.append("---- " + name + " ----\n");
        for(String stuff : stuffings)
        {
            display.append(stuff + "\n");
        }
        return display.toString();
    }

}

六個包子子類

package factoryMethod;

public class ChangshaJiangRouBaoZi extends BaoZi {

    public ChangshaJiangRouBaoZi() 
    {
        setName("長沙醬肉包子");
        stuffings.add("辣椒");
        stuffings.add("炸醬");
        stuffings.add("肉末");
        stuffings.add("乾子");
    }
}

package factoryMethod;

public class ChangshaQingCaiBaoZi extends BaoZi {

    public ChangshaQingCaiBaoZi()
    {
        setName("長沙青菜包子");
        stuffings.add("辣椒");
        stuffings.add("包菜");
        stuffings.add("茄子");
    }

}

package factoryMethod;

public class ChangshaXianRouBaoZi extends BaoZi {

    public ChangshaXianRouBaoZi()
    {
        setName("長沙鮮肉包子");
        stuffings.add("辣椒");
        stuffings.add("鮮肉");
    }

}

package factoryMethod;

public class WuhanJiangRouBaoZi extends BaoZi {

    public WuhanJiangRouBaoZi() 
    {
        setName("武漢醬肉包子");
        stuffings.add("炸醬");
        stuffings.add("肉末");
        stuffings.add("乾子");
    }

}

package factoryMethod;

public class WuhanQingCaiBaoZi extends BaoZi {

    public WuhanQingCaiBaoZi() 
    {
        setName("武漢青菜包子");
        stuffings.add("包菜");
        stuffings.add("茄子");
    }

}

package factoryMethod;

public class WuhanXianRouBaoZi extends BaoZi {

    public WuhanXianRouBaoZi()
    {
        setName("武漢鮮肉包子");
        stuffings.add("鮮肉");
    }

}

一個Main類

package factoryMethod;

public class Main {

    public static void main(String[] args)
    {
        BaoZiFactory wuhanFactory = new BaoZiFactoryWuhan();
        BaoZiFactory changshaFactory = new BaoZiFactoryChangsha();

        BaoZi baoZi = null;

        baoZi = wuhanFactory.makeBaoZi("醬肉");
        System.out.println("Caitao made a " + baoZi.getName() + "\n");

        baoZi = wuhanFactory.makeBaoZi("青菜");
        System.out.println("Caitao made a " + baoZi.getName() + "\n");

        baoZi = changshaFactory.makeBaoZi("鮮肉");
        System.out.println("Lucy made a " + baoZi.getName() + "\n");

        baoZi = changshaFactory.makeBaoZi("青菜");
        System.out.println("Lucy made a " + baoZi.getName() + "\n");

    }

}

執行結果

直接從eclipse複製過來的

Constructor of BaoZiFactory in Wuhan

Constructor of BaoZiFactory in Changsha

Prepare 武漢醬肉包子
Stuffings are:
炸醬
肉末
乾子
Steam for 30 minutes
Caitao made a 武漢醬肉包子

Prepare 武漢青菜包子
Stuffings are:
包菜
茄子
Steam for 30 minutes
Caitao made a 武漢青菜包子

Prepare 長沙鮮肉包子
Stuffings are:
辣椒
鮮肉
Steam for 30 minutes
Lucy made a 長沙鮮肉包子

Prepare 長沙青菜包子
Stuffings are:
辣椒
包菜
茄子
Steam for 30 minutes
Lucy made a 長沙青菜包子

如果沒有工廠方法模式

又要實現同樣的功能怎麼破？程式碼如下(理想輸入條件，沒有異常處理)

public BaoZi makeBaoZi(String place, String type) 
    {
        BaoZi baoZi = null;

        if (place.equals("武漢")) 
        {
            if (type.equals("醬肉"))
            {
                baoZi = new WuhanJiangRouBaoZi();
            } 
            else if (type.equals("青菜"))
            {
                baoZi = new WuhanQingCaiBaoZi();
            }
            else if (type.equals("鮮肉")) 
            {
                baoZi = new WuhanXianRouBaoZi();
            }
        } 
        else if (place.equals("長沙")) 
        {
            if (type.equals("醬肉")) 
            {
                baoZi = new ChangshaJiangRouBaoZi();
            } 
            else if (type.equals("青菜")) 
            {
                baoZi = new ChangshaQingCaiBaoZi();
            } 
            else if (type.equals("鮮肉")) 
            {
                baoZi = new ChangshaXianRouBaoZi();
            } 
        } 

        baoZi.prepare();
        baoZi.steam();

        return baoZi;
    }
優劣之分立馬體現出來了！我們可以看到程式碼變短了（當然了，需要增加一些類作為“額外工作”，這是值得的）
建立包子的new操作“隱藏了”，取而代之的是一個factory物件呼叫createBaoZi方法

public BaoZi makeBaoZi(String place, String type) 
{
    BaoZiFactory factory = null;
    if(place.equals("武漢"))
    {
        factory = new BaoZiFactoryWuhan();
    }
    else if(place.equals("長沙"))
    {
        factory = new BaoZiFactoryChangsha();
    }

    BaoZi baoZi = factory.createBaoZi(type);
    baoZi.prepare();
    baoZi.steam();

    return baoZi;
}

1. 工廠方法模式的優勢：如果位於武漢的工廠需要增加一種口味的包子（這種類似的事情經常發生），比如”熱幹包子“，那麼工廠方法模式只用增加一個包子子類，然後修改武漢工廠子類就行了。

關鍵是下面的程式碼不變，放到哪裡都一樣，以不變應萬變！

BaoZiFactory factory = null;
if(place.equals("武漢"))
{
    factory = new BaoZiFactoryWuhan();
}
else if(place.equals("長沙"))
{
    factory = new BaoZiFactoryChangsha();
}
BaoZi baoZi = factory.createBaoZi(type);

2. 沒有工廠方法模式的劣勢：如果位於武漢的工廠需要增加一種口味的包子（這種類似的事情經常發生），比如”熱幹包子“，那麼所有用於在武漢建立包子的
if( … ) { new … }
else( ) { … }
的程式碼都在後面增加一個
if( 熱幹 ) {new ReGanBaoZiWuhan() }
else( ) { … }

BaoZi baoZi = null;

        if (place.equals("武漢")) 
        {
            if (type.equals("醬肉"))
            {
                baoZi = new WuhanJiangRouBaoZi();
            } 
            else if (type.equals("青菜"))
            {
                baoZi = new WuhanQingCaiBaoZi();
            }
            else if (type.equals("鮮肉")) 
            {
                baoZi = new WuhanXianRouBaoZi();
            }
            *********增加的程式碼*****************
            else if(type.equals("熱幹"))
            {
                baoZi = new WuhanReGanBaoZi();
            }
            ************************************
        } 
        else if (place.equals("長沙")) 
        {
            if (type.equals("醬肉")) 
            {
                baoZi = new ChangshaJiangRouBaoZi();
            } 
            else if (type.equals("青菜")) 
            {
                baoZi = new ChangshaQingCaiBaoZi();
            } 
            else if (type.equals("鮮肉")) 
            {
                baoZi = new ChangshaXianRouBaoZi();
            } 
        }

改一個地方還比較輕鬆，但是關鍵在於很有可能在很多地方都要用到包子。假設100個地方都要建立包子，那麼100個地方的if( … )else( )“的程式碼都要修改！這完全是反人類，違反了開閉原則。

相關推薦

設計模式——工廠方法 Java原始碼

本程式改編自《Head First Design Patterns》中的Pizza例子，我本學期早上經常吃包子。 總共有11個類： 一個工廠父類 ( Creator) 兩個工廠子類 ( Concrete Creator) 一個包子父類 ( Product

Java設計模式——工廠方法&模版方法

ctype sys 通過反射 ets gif pla ons view close 　　Java的泛型一直是我比較感興趣的部分，但是既然說起泛型，就不得不提到擦除。Java泛型是使用擦除實現的，使用泛型時，具體的類型信息都被“擦除”了。舉個例子：List<String

Java設計模式--工廠方法模式

必須 產品 str 應用程序 實現 工廠方法模式 調用 方法 png 角色 抽象工廠：擔任這個角色是工廠方法模式的核心，它是與應用程序無關的。任何在模式中創建對象的工廠類都必須實現這個接口。 具體工廠：擔任這個角色的是實現了抽象工廠接口的具體Java類。具體工廠角色含有與應

Java設計模式-工廠方法模式（Factory Method）

print blog -i pri cnp 三種模式 image void share 工廠方法模式（Factory Method） 工廠模式適合：凡是出現了大量的產品需要創建，並且具有共同的接口時，可以通過工廠方法模式進行創建。在以下的三種模式中，第一種如果傳入的字符串

java常用設計模式--工廠方法模式簡單例子

package com.ruanyun;/** * @Auther: maxw * @Date: 2018/11/12 11:02 * @Description:工廠方法模式:有四個角色，抽象工廠模式，具體工廠模式，抽象產品模式，具體產品模式。不再是由一個工廠類去例項化具體的產品，而是由抽象工廠的子類去例項化

Java設計模式—工廠方法模式&抽象工廠模式

工廠方法模式與抽象工廠模式都是設計模式中重要而且常見的模式。       工廠方法模式：定義一個用於建立物件的介面，讓子類決定例項化哪一個類。工廠方法使一個類的例項化延遲到其子類。 通用類圖如下：        

Java 開發 設計模式 ----工廠方法模式（Factory Method）

工廠方法模式（Factory Method） 工廠方法模式分為三種： 11、普通工廠模式，就是建立一個工廠類，對實現了同一介面的一些類進行例項的建立。首先看下關係圖： 舉一個傳送郵件和簡訊的例子。首先，建立二者的共同介面： public interface Sender {

Java設計模式—工廠方法模式&抽象工廠模式

工廠方法模式與抽象工廠模式都是設計模式中重要而且常見的模式。      工廠方法模式：定義一個用於建立物件的介面，讓子類決定例項化哪一個類。工廠方法使一個類的例項化延遲到其子類。通用類圖如下：     

java設計模式-工廠方法模式

工廠方法模式詳解 　　今天我們主要學習Java設計模式中的工廠方法模式，如果你看過我之前寫的簡單工廠模式會更容易理解下面的講解，為了便於理解工廠方法模式我依然用食品加工廠為案例。 一，概述 　　工廠方法模式去掉了簡單工廠模式中工廠方法的靜態屬性，使得它可以被子類繼承。這樣在簡單工廠模式裡集中在工廠方法上的壓力

Note8:C#設計模式—工廠方法模式（VS 簡單工廠模式 & 抽象工廠模式）

工廠方法模式 blog 抽象工廠 nbsp strong str cnblogs note 設計 一、資源說明 （1）本文有參考：http://www.cnblogs.com/zhili/p/FactoryMethod.html 待更！Note8:C#設計模式—工廠方法

iOS經常使用設計模式——工廠方法（簡單工廠模式，工廠方法模式， 抽象工廠模式）

csdn bst 設計 cto mod 基類 load 引用 角色 1. 簡單工廠模式 怎樣理解簡單工廠，工廠方法。 抽象工廠三種設計模式？ 簡單工廠的生活場景。賣早點的小攤販。他給你提供包子，饅頭，地溝油烙的煎餅等，小販是一個工廠。它生產包子，饅頭，地溝油烙的

C#設計模式——工廠方法模式

osc tor cas 模式 main csharp plan ofa mar 一、引言 　　在簡單工廠中講到簡單工廠模式的缺點，有一點是——簡單工廠模式系統難以擴展，一旦添加新產品就不得不修改簡單工廠方法，這樣就會造成簡單工廠的實現邏輯過於復雜，然而本專題介紹的工廠方法模

設計模式-工廠方法（Factory Method）

log face inf str ace 對象實例 method tee 就是 2018-1-20 by Atlas 應用場景 Template Method Pattern是在父類建立處理邏輯的大綱骨架，而在子類補充具體的處理內容。把Template Method

設計模式-工廠方法模式

集合類 tof col 進行 bool down urn DC 角色 在簡單工廠模式中，我們發現存在很多問題： 由於工廠類集中了所有產品創建邏輯，一旦不能正常工作，整個系統都要受到影響。 要新增產品類的時候，就要修改工廠類的代碼，違反了開放封閉原則（對擴展的開放，對修改的

設計模式-工廠方法

細節 新的 工廠 對象 實例化 理解 如何 例如 子類 定義： 定義一個創建對象的接口，但讓實現這個接口的類來決定實例化哪個類，工廠方法讓類的實例化推遲到子類中進行 類型： 創建型 適用場景： 　　創建對象需要大量重復的代碼 　　客戶端（應用層）不依賴於產品類實例如

android設計模式——工廠方法模式

定義：定義一個用於建立物件的介面，讓子類決定例項化哪個類. 使用場景： 在任何需要生成複雜物件的地方，都可以使用工廠方法模式. 應用舉例：去工廠提貨物，只需說要什麼貨，不必知道貨物是怎麼做出來的 類圖： Factory，抽象的工廠類 ConcreteFactory,具

用心理解設計模式——工廠方法模式 (Factory Method Pattern)

前置文章： 用心理解設計模式——設計模式的原則  設計模式相關程式碼已統一放至 我的 Github   一、定義   建立型模式之一。   Define an interface for creating an object, b

設計模式 --- 工廠方法模式

1.定義 一定一個建立物件的介面，讓子類決定例項化哪個類。   2.使用場景 在任何需要生成複雜物件的地方，都可以使用工廠方法模式。   3.簡單實現 以一個汽車組裝為例，汽車廠主要以組裝一款SUV車型，比如Q3、Q5、Q7，對於這類車型內部差異並不大

C++設計模式——工廠方法模式

問題描述 之前講到了C++設計模式——簡單工廠模式，由於簡單工廠模式的侷限性，比如：工廠現在能生產ProductA、ProductB和ProductC三種產品了，此時，需要增加生產ProductD產品；那麼，首先是不是需要在產品列舉型別中新增新的產品型別標識，然後，修改Fa

23種設計模式----工廠方法模式----建立型模式

工廠方法模式或者說是簡單工廠方法。 ps:學會模板方法再學習工廠方法更簡單，或者說工廠方法模式是在模板方法的基礎上進行設計的。 1.什麼是工廠方法模式 將例項的生成交給子類（出自《圖解設計模式》） 這句話怎麼理解？ 我自己的理解就是把建立和實現分離。 使用工廠