2. 程式人生 > >HeadFirst設計模式讀書筆記之工廠模式

HeadFirst設計模式讀書筆記之工廠模式

阿新 • • 發佈：2018-11-28

1. 簡單工廠

1. 你開了一家披薩店,點披薩的方法可能是這樣:

    public Pizza orderPizza(String type) {
        Pizza pizza;
        if (type.equals("芒果披薩")){
            pizza = new MangoPizza();
        }else if (type.equals("核桃披薩")){
            pizza = new WalnutPizza();
        }else if (type.equals("橙皮披薩")){
            pizza = new FlavedoPizza();
        }else {
            pizza = new StarPizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

可以看到,每當你想增加一種披薩型別,就要修改程式碼,新增一種if else條件.當有多個系統存在orderPizza的需求時,每個系統都要同時修改他們的程式碼.因此,需要將這種例項化具體物件的程式碼封裝起來.

public class PizzaStore {

    SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory){
        this.factory = factory;
    }

    public Pizza orderPizza(String type) {
        Pizza pizza;
        pizza = factory.createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}
 
public class SimplePizzaFactory {

    public Pizza createPizza(String type){
        Pizza pizza = null;
        
        if (type.equals("芒果披薩")){
            pizza = new MangoPizza();
        }else if (type.equals("核桃披薩")){
            pizza = new WalnutPizza();
        }else if (type.equals("橙皮披薩")){
            pizza = new FlavedoPizza();
        }else {
            pizza = new StarPizza();
        }
        
        return pizza;
    }
}

這就是簡單工廠方法,他不算一種設計模式,而是一種程式設計習慣.其要點有二:

1. 將產品定義為抽象類,可以被覆蓋

2. 將具體的產品放到工廠類中來例項化,由工廠建立並返回給客戶,這樣便使得產品的建立邏輯可以解耦合,並增加了複用性

2. 工廠方法

1. 假設你現在有了很多加盟店,每種加盟店根據地區的差異有自己的工廠,但加盟店雖然採用工廠方法建立披薩,但其他部分卻有所不同:烘烤的做法,不切片,使用雜七雜八的盒子...

這時,你想把建立披薩的方法與每家披薩店繫結在一起,讓每家PizzaStore中都使用createPizza()建立pizza,並且這些店還可以擁有一定的製作披薩的自主權.因此,我們需要把PizzaStore和createPizza()定義成抽象的

/**
 * 抽象的PizzaStore
 */
public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza;
        // 使用自己的方法做披薩
        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    // 將做披薩的工廠方法放到PizzaStore中,工廠方法是抽象的,所以依賴子類來處理物件的建立
    public abstract Pizza createPizza(String type);
}

2. 現在由PizzaStore的子類來具體賣披薩

public class BeijingPizzaStore extends PizzaStore {
    @Override
    public Pizza createPizza(String item) {
        if (item.equals("橙皮披薩")){
            return new FlavedoPizza();
        }else {
            return new PekingDuckPizza();
        }
    }
}
public class ChengduPizza extends PizzaStore {
    @Override
    public Pizza createPizza(String type) {
        if (type.equals("芒果披薩")){
            return new MangoPizza();
        }else {
            return new StarPizza();
        }
    }
}

現在,orderPizza()與具體的Pizza實現了一定的解耦合,決定最終Pizza物件的變成了某個具體的pizza店,而pizza店則由顧客來決定

3. 一些對工廠方法的理解:

1. 工廠方法是抽象的,所以依賴子類來建立物件,這樣便將超類的程式碼與具體建立產品的程式碼分割開了

2. 工廠方法必須返回一個產品,超類通常中會用到這個產品

3. 工廠方法將產品與建立者抽象為介面,使他們成為平級的存在,具體的產品建立則使用子類來互動

4. 工廠方法將產品例項化的操作推遲到子類,子類的選擇則由建立者來決定

5. 簡單工廠方法更趨向組合,工廠方法則利用抽象和繼承

6. 簡單工廠封裝了物件的建立,一個工廠處理所有的產品,但對同一個產品不可變更其做法,工廠方法則更有彈性,子類通過重寫可以更改產品的建立

3. 依賴倒置原則

下面是一個簡單粗暴的披薩店:

/**
 * 依賴具體物件的PizzaStore
 */
public class PizzaStore {
    
    public Pizza createPizza(String style, String type){
        Pizza pizza = null;
        if (style.equals("一元檔")){
            if (type.equals("芒果披薩")){
                pizza = new MangoPizza();
            }else if (type.equals("核桃披薩")){
                pizza = new WalnutPizza();
            }
        }else if (style.equals("二元檔")){
            if (type.equals("北京烤鴨披薩")){
                pizza = new PekingDuckPizza();
            }else if (type.equals("橙皮披薩")){
                pizza = new FlavedoPizza();
            }
        }else {
            System.out.println("披薩賣完了");
        }
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

可以看到,這個披薩店依賴於每一個具體的披薩物件,每增加一個披薩就要修改一次程式碼,增加一個依賴,可以說是非常不好用了

從圖中看到,高層元件直接依賴於低層元件而依賴倒置原則的的內容就是:

要依賴抽象,不要依賴具體類
這個原則說明不管高層還是低層元件都不應該依賴具體類,而應該依賴於抽象.如圖所示:

與之前相比高層元件PizzaStore不在直接依賴於具體的Pizza物件,而是依賴於Pizza介面,而具體的Pizza產品則由被高層元件依賴顛倒成了依賴Pizza介面,這就是一種依賴倒置.總體來看,PizzaStore和Pizza都抽象化了,不用再依賴於具體的型別,符合依賴倒置的設計原則.
有三個指導方針可以讓你更好地遵守依賴倒置原則:

  • 變數不可以持有具體類的引用
  • 不要讓類派生自具體類
  • 不要覆蓋基類中已覆蓋的方法

4. 抽象工廠方法:建立產品家族

與普通的工廠方法比較,抽象工廠方法要顯得重型得多: 工廠方法只建立一種產品,抽象工廠方法則建立一個家族的產品

1. 典型做法是建立一個工廠的介面,這個介面負責建立所有的產品家族成員,如建立一個生產調料家族的工廠:

/**
* 原料工廠的介面,實現這樣的介面,可以隨意組合產出各式各樣的調料
* 每個原料都是一個類
*/
public interface SeasoningFactory {

   Chili createChili();
   
   DouBan createDouBan();
   
   Pepper createPepper();
   
   Salt createSalt();

}
/**
 * 郫縣調料生產廠
 */
public class PiXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 郫縣豆瓣
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new PiXianDouBan();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用鹽
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}

/**
 * 灌縣調料生產廠
 */
public class GuanXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 老乾媽豆瓣醬
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new LaoGanMaDouBanJiang();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用鹽
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}

下面是抽象工廠方法的類圖:

從類圖中可以看出來,抽象工廠方法有一個缺點,就是當添加了一個新產品介面時,要去抽象工廠介面中新增一個方法,這會造成一些麻煩

2. 工廠方法與抽象工廠的一些對比

相同點:

  • 都是負責建立物件
  • 都能使程式解耦,將程式從建立大量具體物件的泥潭中拉出來

不同點:

  • 工廠方法用子類來建立具體物件,利用抽象和繼承.抽象工廠包含了一大堆介面,利用組合的思想來建立物件
  • 工廠方法一般用來建立一種產品,抽象工廠則建立一族產品

  • 工廠方法功能簡單,使用輕便.抽象工廠功能強大,使用時會建立大量的類

    3. 下面使用抽象工廠生產的原料來製作披薩

/**
 * 原料工廠的介面,實現這樣的介面,可以隨意組合產出各式各樣的調料
 * 每個原料都是一個類
 */
public interface SeasoningFactory {

    /**
     * 辣椒
     * @return
     */
    Chili createChili();

    /**
     * 豆瓣
     * @return
     */
    DouBan createDouBan();

    /**
     * 花椒
     * @return
     */
    Pepper createPepper();

    /**
     * 鹽
     * @return
     */
    Salt createSalt();

}
/**
 * 豆瓣
 */
public abstract class DouBan {
    public abstract String sayMyName();
}
public class PiXianDouBan extends DouBan {
    @Override
    public String sayMyName() {
        return "郫縣豆瓣";
    }
}
public class LaoGanMaDouBanJiang extends DouBan {
    @Override
    public String sayMyName() {
        return "老乾媽豆瓣醬";
    }
}
/**
 * 郫縣調料生產廠
 */
public class PiXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 郫縣豆瓣
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new PiXianDouBan();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用鹽
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}
/**
 * 灌縣調料生產廠
 */
public class GuanXianSeasoningFactory implements SeasoningFactory {

    /**
     *  虎皮青椒
     * @return
     */
    @Override
    public Chili createChili() {
        return new HuPiQingJiao();
    }

    /**
     * 老乾媽豆瓣醬
     * @return
     */
    @Override
    public DouBan createDouBan() {
        return new LaoGanMaDouBanJiang();
    }

    /**
     * 花椒油
     * @return
     */
    @Override
    public Pepper createPepper() {
        return new HuaJiaoYou();
    }

    /**
     * 食用鹽
     * @return
     */
    @Override
    public Salt createSalt() {
        return new ShiYongYan();
    }
}
/**
 * 每一個披薩都有一組抽象工廠生產的原料
 *
 */
public abstract class Pizza {

    protected String name;

    /**
     * 辣椒
     */
    protected Chili chili;

    /**
     * 豆瓣
     */
    protected DouBan douBan;

    /**
     * 花椒
     */
    protected Pepper pepper;

    /**
     * 鹽
     */
    protected Salt salt;


    /**
     * 在這個方法中,收集抽象工廠生產的原料
     */
    public abstract void prepare();

    public void bake(){
        System.out.println("烘烤...");
    }

    public void cut(){
        System.out.println("切片...");
    }

    public void box() {
        System.out.println("包裝...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString(){
         return "披薩製作完畢:"+name
        +"\n生產原料:"+chili.sayMyName()
                +"\t"+douBan.sayMyName()
                +"\t"+pepper.sayMyName()
                +"\t"+salt.sayMyName();

    }
}
public class ChengduPizza extends Pizza{

    // 調料工廠
    SeasoningFactory seasoningFactory;

    public ChengduPizza(SeasoningFactory seasoningFactory) {
        this.name = "舊成都披薩";
        this.seasoningFactory = seasoningFactory;
    }

    @Override
    public void prepare() {
        System.out.println("開始準備 "+getName()+":");
        chili = seasoningFactory.createChili();
        douBan = seasoningFactory.createDouBan();
        pepper = seasoningFactory.createPepper();
        salt = seasoningFactory.createSalt();
        System.out.println("以下原料準備完畢:"+chili.sayMyName()
        +","+douBan.sayMyName()+","+pepper.sayMyName()+","+salt.sayMyName());
    }
}
public abstract class PizzaStore {

    public abstract Pizza createPizza(String type);
}
public class StarBoundPizzaStore extends PizzaStore {
    @Override
    public Pizza createPizza(String type) {
        Pizza pizza;
        SeasoningFactory factoryA = new PiXianSeasoningFactory();
        SeasoningFactory factoryB = new GuanXianSeasoningFactory();

        if (type.equals("舊成都披薩")){
            pizza = new ChengduPizza(factoryA);;
        }else if (type.equals("新北京披薩")){
            pizza = new PekingPizza(factoryB);
        }else {
            pizza = new ChengduPizza(factoryB);
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

    public static void main(String[] args) {
        PizzaStore pizzaStore = new StarBoundPizzaStore();
        Pizza pizza = pizzaStore.createPizza("舊成都披薩");
        System.out.println(pizza.toString());
        Pizza pizza1 = pizzaStore.createPizza("新北京披薩");
        System.out.println(pizza1.toString());
    }
}
結果:
開始準備 舊成都披薩:
以下原料準備完畢:虎皮青椒,郫縣豆瓣,花椒油,食用鹽
烘烤...
切片...
包裝...
披薩製作完畢:舊成都披薩
生產原料:虎皮青椒   郫縣豆瓣    花椒油 食用鹽
開始準備 新北京披薩:
以下原料準備完畢:虎皮青椒,老乾媽豆瓣醬,花椒油,食用鹽
烘烤...
切片...
包裝...
披薩製作完畢:新北京披薩
生產原料:虎皮青椒   老乾媽豆瓣醬  花椒油 食用鹽

相關推薦

HeadFirst設計模式讀書筆記之工廠模式

1. 簡單工廠 1. 你開了一家披薩店,點披薩的方法可能是這樣: public Pizza orderPizza(String type) { Pizza pizza; if (type.equals("芒果披薩")){ pizza = ne

HeadFirst設計模式讀書筆記之策略模式

1. 例子 1. 做一個鴨子模擬器,裡面有很多不同的鴨子,有的可以游泳,有的可以睡覺,有的可以呱呱叫,一般套路是定義一個鴨子的超類,在 超類裡定義睡覺,游泳,呱呱叫的方法,再讓不同的鴨子子類繼承這個超類,實現自己的display()方法來表現鴨子的行為,像下面這樣: 2. 但如果要加一個可以吃火鍋的鴨子呢,

設計模式讀書筆記-----抽象工廠模式

        在工廠方法模式中，我們使用一個工廠建立一個產品，也就是說一個具體的工廠對應一個具體的產品。但是有時候我們需要一個工廠能夠提供多個產品物件，而不是單一的物件，這個時候我們就需要使用抽象工

設計模式筆記之工廠模式--簡單工廠模式(Simple Factory Pattern)

一、概述：工廠模式就是專門負責將大量有共同介面的類例項化,而且不必事先知道每次是要例項化哪一個類的模式。它定義一個用於建立物件的介面，由子類決定例項化哪一個類。二、簡單工廠模式的結構：三、簡單的例項：1.定義一個介面，代表一類Javabeanpublic interface

設計模式讀書筆記之橋接模式(bridge pattern)

橋接模式：將抽象部分和他的實現部分分離，使他們可以獨立地變化。 我個人認為，說橋接模式和享元模式, 與其說是一種設計模式，還不如說是一種思想, 它體現在對系統或物件的分析階段。當你用橋接模式的思想去分析一個系統或物件,然後用程式碼實現它之後拿給別人看, 未必有人能說出你用了

設計模式學習筆記-抽象工廠模式

工廠方法模式是為了克服簡單工廠模式的缺點而設計出來的,簡單工廠模式的工廠類隨著產品類的增加需要增加額外的程式碼），而工廠方法模式每個具體工廠類只完成單個例項的建立,所以它具有很好的可擴充套件性。。但是在現實生活中，一個工廠只建立單個產品這樣的例子很少 定義： 抽象工廠（Abstract Fa

java設計模式學習筆記--抽象工廠模式

1. 什麼是抽象工廠模式 抽象工廠模式提供一個介面，用於建立相關或依賴物件的家族，而不需要明確指定具體類。 也就是說抽象工廠模式是用來 建立產品的家族的。 為了理解這個定義，我們先要搞清楚什麼是產品的家族。 那麼什麼是產品的家族哪，我的理解就是一群相

java設計模式學習筆記--簡單工廠模式

1. 什麼是簡單工廠模式 簡單工廠模式是屬於建立型模式，又叫做靜態工廠方法（Static Factory Method）模式。簡單工廠模式是由一個工廠物件決定創建出哪一種產品類的例項。但是嚴格來說，簡單工廠模式不是設計模式，它更像是一種程式設計習慣。 2.

設計模式讀書筆記-----職責鏈模式

       去年參加校招要到長沙來，這個對於我來說不是特別喜歡（但又必須的來，誰叫咱不是985、211的娃呢），但是對於某些人來說就是福音了。大四還有課，而且學校抓的比較嚴，所以對於那些想翹課的人來

設計模式學習筆記--簡單工廠模式（Simple Factory Pattern）【建立型模式】

簡單工廠模式： 工廠是用來生成產品的，簡單工廠，說明工廠能力有限因此只生成一個系列的產品。 此係列產品提供一個產品抽象，具體的產品在派生產品中進行實現。 簡單工廠（一個類），用來管理這個系列產品的生產。工廠中會有一個creat（char* name）成員函式name是需要生

設計模式讀書筆記-----建造者模式

       流水作業大家應該都清楚吧！在流水作業中，我們可以將一些複雜的東西給構建出來，例如汽車。我們都知道汽車內部構件比較複雜，由很多部件組成，例如車輪、車門、發動機、方向盤等等，對於我們使用者來

【大話設計模式讀書筆記——工廠方法模式】

down 除了 wikipedia override 客戶 class a over dfa mar 工廠方法模式 工廠方法模式的實質是“定義一個創建對象的接口，但讓實現這個接口的類來決定實例化哪個類。工廠方法讓類的實例化推遲到子類中進行。 工廠方法模式 VS 簡單工廠

js設計模式第四章 工廠方法模式 讀書筆記

對於建立多類物件，簡單工廠就不太實用了。  通過工廠方法模式可以輕鬆的建立多個類的例項物件，而且建立物件的方式避免了使用者與物件類之間的耦合，使用者不必關心建立該物件的具體類，只需呼叫工廠方法即可。 安全的工廠方法模式 var Factory=function(type,con

js設計模式第三章 簡單工廠模式 讀書筆記

簡單工廠模式又叫靜態工廠方法，由一個工廠物件決定建立某一種產品物件類的例項。主要用來建立同一類的物件。 比如提示彈窗類 function createPop(type,text){ //建立一個物件，並對物件拓展屬性和方法 var o = new Object();

js設計模式第七章 語言之魂——原型模式 讀書筆記

原型模式：用原型例項指向建立物件的類，使用於建立新的物件的類共享原型物件的屬性以及方法。 基於原型鏈實現物件之間的繼承，這種繼承是基於一種對方法或屬性的共享，而不是對方法和屬性的複製。 原型模式就是將可複用的、可共享的、耗時大的從基類中提出來然後放在其原型中，然後子類通過組合繼承或者寄生組合

js設計模式第五章 抽象工廠模式 讀書筆記

抽象工廠模式(Abstract Factory) 通過類的抽象使得業務適用於一個產品類簇的建立，而不負責建立某一類產品的例項。 JS中是沒有直接的抽象類的，因此我們需要在類的方法中丟擲錯誤來模擬抽象類，如果繼承的子類中沒有覆寫該方法而呼叫，就會丟擲錯誤。 //汽車抽象類 var Car = fu

設計模式讀書筆記-工廠模式

單例模式的學習 優化了效能，節省記憶體開支 單例模式一般沒有介面，比較難以拓展，這也意味著難以測試（沒有mock） 單例模式也有執行緒安全問題（懶漢式可能有執行緒安全問題） 如果實現了cloneable介面，並實現了clone方法，則可以直接通過物件複製的形式創

設計模式讀書筆記-----工廠方法模式

        一、問題                                                                                        

設計模式(c++)筆記之二（AbstractFactory抽象工廠模式）

一、簡介：     抽象工廠，提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。對於工廠方法來說，抽象工廠可實現一系列產品的生產，抽象工廠更注重產品的組合。 AbstractFactory 模式典型的結構圖為:  圖 2-1

《大話設計模式》讀書筆記之C++實現--chapter22橋接模式

橋接模式的核心在於理解好繼承屬於is-a的關係，當我們使用繼承的時候先要在心裡問自己一遍子類是不是一個父類，如果答案是否，那我們就要考慮如何重新定義父類實現更好的抽象，此時我們可以聯想到合成/聚合關係，