02.工廠設計模式

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

簡單工廠模式（靜態工廠模式）

簡單工廠模式是屬於建立型模式，是工廠模式的的一種，簡單工廠模式是有一個工廠物件決定創建出那一種產品類的例項。簡單工廠模式是工廠模式家族的最簡單實用的模式。
簡單工廠模式:定義一個建立物件的類，由這個類來建立例項化物件的行為（程式碼）
在軟體開發當中，當我們會用到大量的建立某種、某類或者某批物件時，就會使用工廠模式。

程式碼示例：

/**
 * @author 通過程式看世界
 * @version 1.0
 * 將Pizza做成抽象類
 */
public abstract class Pizza {
    protected String name; //披薩的名字

    //準備原材料，不同的披薩不一樣,因此.我們做成抽象方法
    public abstract void prepare();

    public void bake() {
        System.out.println(name + "backing");
    }

    public void cut() {
        System.out.println(name + "cutting");
    }

    //打包
    public void box() {
        System.out.println(name + "boxing");
    }

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

}

/**
 * @author 通過程式看世界
 * @version 1.0
 * 乳酪披薩
 */
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("給製作乳酪披薩準備原材料");
    }
}

/**
 * @author 通過程式看世界
 * @version 1.0
 * 希臘披薩
 */
public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("給希臘披薩準備原材料");
    }
}

/**
 * @author 通過程式看世界
 * @version 1.0
 * 簡單工廠類
 */
public class SimpleFactor {
    //根據orderType返回對應的Pizza物件
    public Pizza createPizza(String type) {
        System.out.println("使用簡單工廠模式");
        Pizza pizza = null;
        if (type.equals("greek")){
            pizza = new CheesePizza();
            pizza.setName("希臘披薩");
        }else if (type.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("乳酪披薩");
        }
        return pizza;
    }
}

/**
 * @author 通過程式看世界
 * @version 1.0
 * 訂購披薩的類
 */
public class OrderPizza {
    //定義一個一個簡單工廠物件
    SimpleFactor simpleFactor;
    Pizza pizza;

    public OrderPizza(SimpleFactor simpleFactor) {
        setSimpleFactor(simpleFactor);
    }

    public void setSimpleFactor(SimpleFactor simpleFactor) {
        String type = ""; //使用者輸入
        this.simpleFactor = simpleFactor; //設定簡單工廠物件
        do {
            type = getType();
            pizza = this.simpleFactor.createPizza(type);

            //輸出pizza
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("訂購pizza失敗！");
                break;
            }
        } while (true);

    }



    //寫一個方法，可以獲取客戶希望訂購的Pizza種類
    private String getType() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = bufferedReader.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

}

/**
 * @author 通過程式看世界
 * @version 1.0
 * 相當於一個客戶端
 */
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new SimpleFactor());
        System.out.println("退出程式");
    }
}

程式執行結果

input pizza type:
cheese
使用簡單工廠模式
給製作乳酪披薩準備原材料
乳酪披薩backing
乳酪披薩cutting
乳酪披薩boxing
input pizza type:
greek
使用簡單工廠模式
給製作乳酪披薩準備原材料
希臘披薩backing
希臘披薩cutting
希臘披薩boxing
input pizza type:

程式碼分析
- 後期我們需要增加新的披薩型別，只需要在建立一個披薩類，在工廠類當中做出if判斷處理即可

工廠方式模式

定義一個建立物件的抽象方法，由子類決定要例項化的類，工廠方法模式將物件的例項化推遲到子類。
需求：客戶在點披薩的時候，可以點不同口味的披薩。比如：北京的乳酪pizza、北京的胡椒pizza、或者倫敦的乳酪pizza、倫敦的胡椒pizza

程式碼例項：

package com.db.factormethod.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 將Pizza做成抽象類
 */
public abstract class Pizza {
    protected String name; //準備

    //準備原材料，不同的披薩不一樣,因此.我們做成抽象方法
    public abstract void prepare();

    public void bake() {
        System.out.println(name + "backing");
    }

    public void cut() {
        System.out.println(name + "cutting");
    }

    //打包
    public void box() {
        System.out.println(name + "boxing");
    }

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

package com.db.factormethod.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 倫敦的胡椒披薩
 */
public class LDPepperPizza extends Pizza{
    @Override
    public void prepare() {
        setName("倫敦的胡椒披薩");
        System.out.println("為倫敦的胡椒披薩準備原材料");
    }
}

package com.db.factormethod.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 倫敦的胡椒披薩
 */
public class LDCheesePizza extends Pizza{
    @Override
    public void prepare() {
        setName("倫敦的胡椒披薩");
        System.out.println("為倫敦的胡椒披薩準備原材料");
    }
}

package com.db.factormethod.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class BJPepperPizza extends Pizza{
    @Override
    public void prepare() {
        setName("北京的胡椒披薩");
        System.out.println("為北京的胡椒披薩準備原材料");
    }
}

package com.db.factormethod.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class BJCheesePizza extends Pizza{
    @Override
    public void prepare() {
        setName("北京乳酪披薩");
        System.out.println("為北京的乳酪pizza準備原材料");
    }
}

package com.db.factormethod.order;
import com.db.factor.order.SimpleFactor;
import com.db.factormethod.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 訂購披薩的類
 */
public abstract class OrderPizza {


    public OrderPizza() {
        Pizza pizza = null;
        String type; //訂購披薩的型別
        do {
            type = getType();
            pizza = createPizza(type);
            //輸出Pizza的製作過程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.bake();
        } while (true);
    }

    //定義一個抽象方法，createPizza，讓各個工廠類自己去實現
    public abstract Pizza createPizza(String type);

    //寫一個方法，可以獲取客戶希望訂購的Pizza種類
    private String getType() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = bufferedReader.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }
}

package com.db.factormethod.order;

import com.db.factormethod.pizza.LDCheesePizza;
import com.db.factormethod.pizza.LDPepperPizza;
import com.db.factormethod.pizza.Pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 倫敦訂購披薩的類
 */
public class LDOrderPizza extends OrderPizza {
    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (type.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

package com.db.factormethod.order;
import com.db.factormethod.pizza.BJCheesePizza;
import com.db.factormethod.pizza.BJPepperPizza;
import com.db.factormethod.pizza.Pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 北京訂購披薩的類
 */
public class BJOrderPizza extends OrderPizza{

    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if (type.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

package com.db.factormethod.order;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class PizzaStore {
    public static void main(String[] args) {
        new BJOrderPizza();
    }
}

執行結果

input pizza type:
cheese
為北京的乳酪pizza準備原材料
北京乳酪披薩backing
北京乳酪披薩cutting
北京乳酪披薩backing
input pizza type:
pepper
為北京的胡椒披薩準備原材料
北京的胡椒披薩backing
北京的胡椒披薩cutting
北京的胡椒披薩backing

抽象工廠模式

抽象工廠模式，定義了一個interface用於建立相關或者有依賴關係的物件簇，而無需指明具體的類
抽象工廠模式可以將簡單工廠模式和工廠方法模式進行整合
從設計層面來看，抽象工廠模式就是對簡單工廠模式的改進（或者稱為進一步的抽象）
將工廠抽象成兩層，AbsFactory（抽象工廠）和具體實現的工廠子類，程式設計師可以根據建立物件型別使用相應的工廠子類。這樣將單個的簡單工廠類變成了工廠簇，更加有利於程式碼的維護和擴充套件

程式碼示例:

package com.db.absfactory.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 將Pizza做成抽象類
 */
public abstract class Pizza {
    protected String name; //準備

    //準備原材料，不同的披薩不一樣,因此.我們做成抽象方法
    public abstract void prepare();

    public void bake() {
        System.out.println(name + "backing");
    }

    public void cut() {
        System.out.println(name + "cutting");
    }

    //打包
    public void box() {
        System.out.println(name + "boxing");
    }

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

}

package com.db.absfactory.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 倫敦的胡椒披薩
 */
public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("倫敦的胡椒披薩");
        System.out.println("為倫敦的胡椒披薩準備原材料");
    }
}

package com.db.absfactory.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 倫敦的胡椒披薩
 */
public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("倫敦的胡椒披薩");
        System.out.println("為倫敦的胡椒披薩準備原材料");
    }
}

package com.db.absfactory.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的胡椒披薩");
        System.out.println("為北京的胡椒披薩準備原材料");
    }
}

package com.db.absfactory.pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京乳酪披薩");
        System.out.println("為北京的乳酪pizza準備原材料");
    }
}

package com.db.absfactory.order;

import com.db.absfactory.pizza.Pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 抽象工廠模式的抽象層（介面）
 */
public interface IAbsFactory {
    //讓下面的工廠子類去具體實現
    public Pizza createPizza(String type);
}

package com.db.absfactory.order;

import com.db.absfactory.pizza.BJCheesePizza;
import com.db.absfactory.pizza.BJPepperPizza;
import com.db.absfactory.pizza.Pizza;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 北京的工廠
 */
public class BJFactor implements IAbsFactory {
    @Override
    public Pizza createPizza(String type) {
        System.out.println("使用抽象工廠模式");
        Pizza pizza = null;
        if (type.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if(type.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

package com.db.absfactory.order;

import com.db.absfactory.pizza.*;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class LDFactor implements IAbsFactory{
    @Override
    public Pizza createPizza(String type) {
        System.out.println("使用抽象工廠模式");
        Pizza pizza = null;
        if (type.equals("cheese")){
            pizza = new LDCheesePizza();
        }else if(type.equals("pepper")){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

package com.db.absfactory.order;

import com.db.absfactory.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 通過程式看世界
 * @version 1.0
 * 訂購披薩的類
 */
public class OrderPizza {
    IAbsFactory iAbsFactory;

    public OrderPizza(IAbsFactory iAbsFactory) {
        setiAbsFactory(iAbsFactory);
    }

    public void setiAbsFactory(IAbsFactory iAbsFactory) {
        this.iAbsFactory = iAbsFactory;
        String type = "";
        Pizza pizza = null;
        do {
            type = getType();
            pizza = iAbsFactory.createPizza(type);
            //輸出披薩的製作guoc
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("訂購失敗");
            }
        } while (true);
    }

    //寫一個方法，可以獲取客戶希望訂購的Pizza種類
    private String getType() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = bufferedReader.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

}

package com.db.absfactory.order;

import com.sun.org.apache.bcel.internal.generic.NEW;

/**
 * @author 通過程式看世界
 * @version 1.0
 */
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new BJFactor());
    }
}

執行結果

input pizza type:
pepper
使用抽象工廠模式
為北京的胡椒披薩準備原材料
北京的胡椒披薩backing
北京的胡椒披薩cutting
北京的胡椒披薩boxing
input pizza type:
cheese
使用抽象工廠模式
為北京的乳酪pizza準備原材料
北京乳酪披薩backing
北京乳酪披薩cutting
北京乳酪披薩boxing

JDK當中的工廠模式

Calendar原始碼分析

Calendar類當中的createCalendar方法就是採用了簡單工廠模式，根據傳輸的不同的aLocale 返回不同的Calendar例項

 private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
       Calendar cal = null;
       if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        return cal;
    }

工廠模式的總結

工廠模式的意義
1. 將例項化物件的程式碼提取出來，放到一個類當中進行統一管理和維護，達到和主專案的依賴關係的解耦合，從而提高專案的擴充套件性和維護性
三種工廠模式
1. 簡單工廠模式
2. 工廠方法模式
3. 抽象工廠模式
設計模式的依賴抽象原則
1. 建立物件例項的時候，不要直接new類，而是把這個new類的動作放到一個工廠的方法當中，並且返回，有的書上說，變數不要直接持有具體類的引用。
2. 不要讓類繼承具體類，而是繼承抽象類或者實現介面
3. 不要覆蓋基類中已經實現的方法

02.工廠設計模式

簡單工廠模式（靜態工廠模式）簡單工廠模式是屬於建立型模式，是工廠模式的的一種，簡單工廠模式是有一個工廠物件決定創建出那一種產品類的例項。簡單工廠模式是工廠模式家族的最簡單實用的模式。

從買車到工廠設計模式(三件套)

上文回顧: 簡單工廠模式連結:juejin.im/post/5d4d39… 簡單工廠模式核心程式碼: public class CarFactory {

工廠設計模式抽象工廠

1.抽象工廠使用場景使用端要不斷建立某類物件，並且這類物件可以細分為不同種類。此時可以使用抽象工廠，其細分的種類由不同工廠建立。

工廠設計模式

1.工廠方法模式的主要優點有：使用者只需要知道具體工廠的名稱就可得到所要的產品，無須知道產品的具體建立過程；

抽象工廠設計模式

1.說明　　前面介紹的工廠方法模式中考慮的是一類產品的生產，如畜牧場只養動物、電視機廠只生產電視機、計算機軟體學院只培養計算機軟體專業的學生等。　　同種類稱為同等級，也就是說：工廠方法模式只考慮生產同等

設計模式：工廠設計模式介紹及3種寫法（簡單工廠、工廠方法、抽象工廠）

0、介紹給一個背景：一個pizza訂購專案，pizza本身的種類要便於擴充套件和維護，那麼種類很多、製作過程也不少、還要完成訂購的功能。

設計模式-工廠設計模式

背景：在Java中，萬物皆物件。要想使用這些物件，就需要建立它，如果在使用該物件的類中都採用new方式建立該物件，會嚴重耦合，假如要更換物件，所以new該物件的地方都要做修改，這違背了軟體的開閉設計原則。

簡單工廠設計模式

1class Program 2{ 3static void Main(string[] args) 4{ 5Console.WriteLine(\"請輸入您想要的筆記本品牌\");

[PHP] 抽象工廠設計模式-建立型設計模式

抽象工廠:在不指定具體類的情況下建立一系列相關或從屬物件。通常，建立的類都實現相同的介面。抽象工廠的客戶端並不關心這些物件的建立方式，只是知道它們如何組合在一起。

如何在聚合支付平臺，巧用模板+工廠設計模式來實現非同步回撥

非同步回撥流程解析報文（驗證簽名）日誌收集（相同）如果解析報文成功的話，修改支付狀態為已經成功.返回不同的支付結果

反射與工廠設計模式

技術標籤：java後端一、什麼是反射 Java是先編譯再執行的語言，而反射可以讓我們在程式執行時動態載入類並獲取類的詳細資訊，本質是JVM得到java.lang.Class物件之後，再對class物件進行反編譯，從而獲取物件的各

Java面向物件程式設計——工廠設計模式（Factory）

技術標籤：Java面向物件程式設計設計模式程式語言jvmjava 觀察如下程式（主要觀察Main方法）：

C++實現工廠設計模式

技術標籤：設計模式c++設計模式 C++實現工廠設計模式在做Data-Driven設計的時候，我們希望能物件的建立能依執行時檔案的讀入而不是硬編碼在程式碼裡。比如在設計遊戲時，我們希望能夠做到根據外部配置檔案（可由

【工廠設計模式】- 簡單工廠模式&工廠方法模式&抽象工廠模式

技術標籤：Java基礎java設計模式簡單工廠模式：建立一個工廠類，對某一個介面的實現類，或這某一父類的子類建立例項。基類：Animal.java

23種設計模式(一)---簡單工廠設計模式

簡單工廠設計模式---透徹講解一. 什麼是工廠理解簡單工廠設計模式, 首先要理解什麼是工廠. 我們身邊有很多工廠. 釀酒的酒廠, 製衣的衣廠, 加工肉類的肉加工廠等等. 這些工廠他們到底是怎麼釀酒的? 怎麼製衣的?怎麼

Java工廠設計模式

什麼是工廠模式老規矩先用比較難理解的官方語言來表達，工廠模式是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。在工廠模式中，我們在建立物件時不會對客戶

【設計模式】工廠設計模式

工廠設計模式1.概述在java中，萬物皆物件，這些物件都需要建立，如果建立的時候直接new該物件，就會對該物件耦合嚴重，假如我們要更換物件，所有new物件的地方都需要修改一遍，這顯然違背了軟體設計的開閉原則。如果

設計模式之工廠設計模式

1.開發環境 IDEA版本： 2022.1.4 JDK版本：17.0.3 2.模式由來 2.1 自定義MailSender類 2.2 自定義Computer類

【設計模式從入門到精通】02-工廠模式

工廠模式筆記來源：尚矽谷Java設計模式（圖解+框架原始碼剖析）目錄工廠模式傳統方式1、簡單工廠模式2、靜態工廠模式3、工廠方法模式4、抽象工廠模式JDK 原始碼分析小結

設計模式-抽象工廠模式例項-02

一、實驗目的和要求： 1. 抽象工廠模式的運用（1）案例背景：計算機包含記憶體（RAM），CPU等硬體裝置

02.工廠設計模式

簡單工廠模式（靜態工廠模式）

工廠方式模式

抽象工廠模式

抽象工廠模式

JDK當中的工廠模式

Calendar原始碼分析

工廠模式的總結

相關推薦