好，我是程序員雪球。

今天我們來了解設(shè)計模式之工廠模式。

工廠模式有簡單工廠模式、工廠方法模式和抽象工廠模式三種，下面是這三種模式的優(yōu)缺點對比、使用場景以及代碼實例：

一、簡單工廠模式

1. 優(yōu)點：

- 客戶端不需要知道具體產(chǎn)品類的類名，只需要知道具體產(chǎn)品類所對應(yīng)的參數(shù)即可，通過引入配置文件，可以在不修改任何客戶端代碼的情況下更換和增加新的具體產(chǎn)品類，在一定程度上提高了系統(tǒng)的靈活性。

- 工廠類包含了必要的邏輯判斷，根據(jù)客戶端的選擇條件動態(tài)實例化產(chǎn)品類，客戶端可以省去與具體產(chǎn)品類的關(guān)聯(lián)，降低了系統(tǒng)的耦合度。

- 可以將產(chǎn)品的創(chuàng)建和使用分離，客戶端無需關(guān)心產(chǎn)品的創(chuàng)建過程，只需調(diào)用工廠類即可獲取產(chǎn)品對象，符合開閉原則。

2. 缺點：

- 不符合開閉原則，工廠類集中了所有產(chǎn)品創(chuàng)建邏輯，一旦不能正常工作，整個系統(tǒng)都要受到影響。

- 難以支持新種類的產(chǎn)品。如果添加新產(chǎn)品就需要修改工廠類的創(chuàng)建邏輯，違背了開閉原則。

3. 使用場景：

- 工廠類負(fù)責(zé)創(chuàng)建的對象比較少。

- 客戶端只知道傳入工廠類的參數(shù)，對于如何創(chuàng)建對象不關(guān)心。

4. 代碼實例：

class Phone:

def __init__(self, brand, price):

self.brand=brand

self.price=price

def show(self):

print(f"{self.brand}的價格是{self.price}元")

class Factory:

def create_phone(self, brand, price):

if brand=="Huawei":

return Huawei()

elif brand=="Xiaomi":

return Xiaomi()

elif brand=="Apple":

return Apple()

else:

return None

# 創(chuàng)建工廠對象并生產(chǎn)產(chǎn)品

factory=Factory()

phone=factory.create_phone("Huawei", 3000)

phone.show()

在這個例子中，我們定義了一個 Phone 類，它有兩個屬性 brand 和 price ，以及一個方法 show 。然后，我們定義了一個 Factory 類，它有一個方法 create_phone ，根據(jù)傳入的 brand 和 price 返回相應(yīng)的 phone 對象。最后，我們創(chuàng)建了一個 Factory 對象 factory ，并調(diào)用 create_phone 方法來生產(chǎn) phone 對象。根據(jù)傳入的參數(shù)，工廠會返回相應(yīng)的 phone 對象。

二、工廠方法模式

1. 優(yōu)點：

- 符合開閉原則，在不修改工廠類的情況下，可以增加新的具體產(chǎn)品類。

- 工廠方法模式把具體產(chǎn)品的創(chuàng)建委托給相應(yīng)的工廠類，客戶端只需要知道具體產(chǎn)品類所對應(yīng)的工廠類即可，無需關(guān)心產(chǎn)品的創(chuàng)建過程，符合迪米特法則。

2. 缺點：

- 在添加新產(chǎn)品時，需要同時添加新的工廠類，增加了系統(tǒng)的復(fù)雜度。

3. 使用場景：

- 工廠方法模式適用于產(chǎn)品種類較多的情況，可以將產(chǎn)品的創(chuàng)建和使用分離，便于系統(tǒng)的擴展和維護(hù)。

- 客戶端不知道具體產(chǎn)品類的類名，只需要知道具體產(chǎn)品類所對應(yīng)的工廠類即可，通過引入配置文件，可以在不修改任何客戶端代碼的情況下更換和增加新的具體產(chǎn)品類，在一定程度上提高了系統(tǒng)的靈活性。

4. 代碼實例：

class Phone:

def __init__(self, brand, price):

self.brand=brand

self.price=price

def show(self):

print(f"{self.brand}的價格是{self.price}元")

class Factory:

def create_phone(self, brand):

if brand=="Huawei":

return Huawei()

elif brand=="Xiaomi":

return Xiaomi()

elif brand=="Apple":

return Apple()

else:

return None

# 創(chuàng)建工廠對象并生產(chǎn)產(chǎn)品

factory=Factory()

phone=factory.create_phone("Huawei")

phone.show()

在這個例子中，我們定義了一個 Phone 類，它有兩個屬性 brand 和 price ，以及一個方法 show 。然后，我們定義了一個 Factory 類，它有一個方法 create_phone ，根據(jù)傳入的 brand 返回相應(yīng)的 phone 對象。最后，我們創(chuàng)建了一個 Factory 對象 factory ，并調(diào)用 create_phone 方法來生產(chǎn) phone 對象。根據(jù)傳入的參數(shù)，工廠會返回相應(yīng)的 phone 對象。

三、抽象工廠模式

1. 優(yōu)點：

- 符合開閉原則，在不修改工廠類的情況下，可以增加新的產(chǎn)品族，在不修改客戶端的情況下，可以增加新的具體產(chǎn)品。

- 抽象工廠模式可以提供更高的靈活性和擴展性，當(dāng)需要增加新的產(chǎn)品族時，只需要添加新的具體工廠類即可，不需要修改已有代碼，符合開閉原則。

2. 缺點：

- 抽象工廠模式的類層次結(jié)構(gòu)比較復(fù)雜，不太適合小型項目。

3. 使用場景：

- 抽象工廠模式適用于需要創(chuàng)建一系列相關(guān)或相互依賴的對象的情況，可以將對象的創(chuàng)建和使用分離，便于系統(tǒng)的擴展和維護(hù)。

- 抽象工廠模式可以與工廠方法模式結(jié)合使用，將產(chǎn)品族的創(chuàng)建和具體產(chǎn)品的創(chuàng)建分離，進(jìn)一步提高系統(tǒng)的靈活性和擴展性。

4. 代碼實例：

class Phone:

def __init__(self, brand, price):

self.brand=brand

self.price=price

def show(self):

print(f"{self.brand}的價格是{self.price}元")

class Factory:

def create_phone(self, brand, series):

if brand=="Huawei":

if series=="Mate":

return Mate()

elif series=="P":

return P()

elif series=="Nova":

return Nova()

else:

return None

elif brand=="Xiaomi":

if series=="Mi":

return Mi()

elif series=="Redmi":

return Redmi()

else:

return None

elif brand=="Apple":

if series=="iPhone":

return iPhone()

elif series=="iPad":

return iPad()

else:

return None

else:

return None

# 創(chuàng)建工廠對象并生產(chǎn)產(chǎn)品

factory=Factory()

phone=factory.create_phone("Huawei", "Mate")

phone.show()

在這個例子中，我們定義了一個 Phone 類，它有兩個屬性 brand 和 price ，以及一個方法 show 。然后，我們定義了一個 Factory 類，它有一個方法 create_phone ，根據(jù)傳入的 brand 和 series 返回相應(yīng)的 phone 對象。最后，我們創(chuàng)建了一個 Factory 對象 factory ，并調(diào)用 create_phone 方法來生產(chǎn) phone 對象。根據(jù)傳入的參數(shù)，工廠會返回相應(yīng)的 phone 對象。

總的來說，工廠模式是一種創(chuàng)建對象的設(shè)計模式，它將對象的創(chuàng)建和使用分離，客戶端不需要知道具體產(chǎn)品類的類名，只需要知道具體產(chǎn)品類所對應(yīng)的工廠類即可，通過引入配置文件，可以在不修改任何客戶端代碼的情況下更換和增加新的具體產(chǎn)品類，在一定程度上提高了系統(tǒng)的靈活性。

總結(jié)

剛剛我們分別講了三種工廠模式的優(yōu)缺點，應(yīng)用場景，以及代碼示例。我們來回顧一下：

一、簡單工廠模式

優(yōu)點：

1、提高靈活性；

2、降低系統(tǒng)耦合性；

3、符合開閉原則；

缺點：

1、會受到工廠類的影響；

2、添加需要修改工廠類；

使用場景：

1、創(chuàng)建比較少的對象；

2、客戶端只關(guān)注傳入工廠類的參數(shù)；

二、工廠方法模式

優(yōu)點：

1、符合開閉原則；

2、符合迪米特法則；

缺點：

1、需要添加工廠類

使用場景：

1、產(chǎn)品種類較多情況；

2、客戶端只需要知道對應(yīng)工廠類；

三、抽象工廠模式

優(yōu)點：

1、符合開閉原則；

2、更具靈活性和擴展性；

缺點：

1、層次結(jié)構(gòu)復(fù)雜，不適合小型項目；

使用場景：

1、適用于需要創(chuàng)建一系列相關(guān)或相互依賴的對象的情況；

2、可以與工廠方法模式結(jié)合使用，將產(chǎn)品族的創(chuàng)建和具體產(chǎn)品的創(chuàng)建分離，進(jìn)一步提高系統(tǒng)的靈活性和擴展性。

想要了解更多設(shè)計模式相關(guān)知識，請關(guān)注我吧。

當(dāng)今數(shù)字化浪潮的沖擊下，工廠建設(shè)的數(shù)字化轉(zhuǎn)型已,成為不可逆轉(zhuǎn)的趨勢。而在這一進(jìn)程中，工業(yè)三防平板正逐漸斬露頭角，發(fā)揮著越來越重要的作用。隨著工業(yè)4.0理念的不斷深入，工廠對于生產(chǎn)效率、質(zhì)量控制、管理精細(xì)化的要求越來越高。數(shù)字化技術(shù)的應(yīng)用成為實現(xiàn)這些目標(biāo)的關(guān)鍵手段。工業(yè)三防平板憑借其獨特的優(yōu)勢，成為了工廠數(shù)字化建設(shè)中的得力助手。

工業(yè)三防平板具備出色的防護(hù)性能。防水、防塵、防摔的特點使其能夠在惡劣的工廠環(huán)境中穩(wěn)定運行，無論是充滿粉塵的車間，還是潮濕的加工區(qū)域，都能應(yīng)對自如。這一特性大大減少了設(shè)備因環(huán)境因素導(dǎo)致的故障和損壞，提高了設(shè)備的可靠性和使用壽命。

工業(yè)三防平板具有強大的移動性和便攜性。工人可以手持平板在工廠內(nèi)自由移動，隨時隨地獲取和處理生產(chǎn)數(shù)據(jù)。無論是進(jìn)行設(shè)備巡檢、質(zhì)量檢測，還是查看生產(chǎn)計劃和工藝文件，都能通過平板輕松完成。這種移動辦公的模式極大地提高了工作效率，減少了信息傳遞的時間和誤差。

工業(yè)三防平板能夠與工廠內(nèi)的各種系統(tǒng)和設(shè)備實現(xiàn)無縫對接。它可以集成生產(chǎn)管理系統(tǒng)(MES)、企業(yè)資源規(guī)劃(ERP)等軟件，實時獲取生產(chǎn)進(jìn)度、庫存信息、質(zhì)量報告等關(guān)鍵數(shù)據(jù)。

同時，通過藍(lán)牙、WIF等通信方式，還能與傳感器、智能儀表等設(shè)備進(jìn)行連接，實現(xiàn)數(shù)據(jù)的自動采集和傳輸，為工廠的智能化管理提供了堅實的基礎(chǔ)。

在實際應(yīng)用中，許多工廠已經(jīng)嘗到了工業(yè)三防平板帶來的甜頭。例如，一家汽車零部件制造工廠引入工業(yè)三防平板后，質(zhì)檢人員可以在現(xiàn)場直接錄入檢測數(shù)據(jù)，并與標(biāo)準(zhǔn)值進(jìn)行對比，及時發(fā)現(xiàn)不合格產(chǎn)品。生產(chǎn)管理人員通過平板實時掌握生產(chǎn)線上的設(shè)備運行狀況，提前安排維護(hù)保養(yǎng)，降低了設(shè)備故障率。

心作用

定義一個用于創(chuàng)建產(chǎn)品的接口，由子類決定生產(chǎn)什么產(chǎn)品。

分類

1. 簡單工廠模式
2. 工廠方法模式
3. 抽象工廠模式

簡單工廠模式

簡單工廠模式是有一個工廠對象決定創(chuàng)建出哪一種產(chǎn)品類的實例。即定義了一個創(chuàng)建對象的類，由這個類來封裝實例化對象的行為。

簡單工廠有兩種模式：

1. 普通簡單工廠模式；
2. 靜態(tài)簡單工廠模式；

簡單工廠模式的主要角色

• 抽象產(chǎn)品：定義了產(chǎn)品的規(guī)范，描述了產(chǎn)品的主要特征和功能；
• 具體產(chǎn)品：實現(xiàn)或者繼承抽象產(chǎn)品的子類；
• 具體工廠：提供了創(chuàng)建產(chǎn)品的方法，調(diào)用者通過該方法創(chuàng)建產(chǎn)品；

優(yōu)勢劣勢

● 簡單工廠模式，通過接收的參數(shù)不同來返回不同的對象實例；
● 對于增加新產(chǎn)品（新功能）無能為力！不修改代碼的話，是無法擴展的。不滿足開閉原則。

簡單工廠模式的實現(xiàn)

抽象類Pizza

package top.simba1949.factory.simple.pizza;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2020/5/9 11:45
 */
@Slf4j
@Data
public abstract class Pizza {

    protected String name;

    /**
     * 準(zhǔn)備原材料，每種 Pizza 原材料不一致
     */
    public abstract void prepare();

    /**
     * Pizza 烘烤
     */
    public void bake() {
        log.info("{} : baking", name);
    }

    /**
     * Pizza 切割
     */
    public void cut() {
        log.info("{} : cutting", name);
    }

    /**
     * Pizza 打包
     */
    public void box() {
        log.info("{} : boxing", name);
    }
}

抽象類Pizza的實現(xiàn)

package top.simba1949.factory.simple.pizza;

import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2020/5/9 11:51
 */
@Slf4j
public class CheesePizza extends Pizza {

    @Override
    public void prepare() {
        log.info("芝士Pizza原材料準(zhǔn)備中。。。");
    }
}

package top.simba1949.factory.simple.pizza;

import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2020/5/9 11:52
 */
@Slf4j
public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        log.info("希臘風(fēng)味Pizza原材料準(zhǔn)備中。。。");
    }
}

簡單工廠（靜態(tài)）

package top.simba1949.factory.simple.staticFacotry;

import top.simba1949.factory.simple.pizza.CheesePizza;
import top.simba1949.factory.simple.pizza.GreekPizza;
import top.simba1949.factory.simple.pizza.Pizza;

/**
 * @author anthony
 * @datetime 2020/5/9 12:51
 */
public class SimpleFactoryByStatic {

    public static Pizza orderPizza(String type) {
        Pizza pizza=null;

        if ("cheese".equalsIgnoreCase(type)) {
            pizza=new CheesePizza();
            pizza.setName("cheese");
        } else if ("greek".equalsIgnoreCase(type)) {
            pizza=new GreekPizza();
            pizza.setName("greek");
        }

        if (null !=pizza){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }

        return pizza;
    }
}

簡單工廠模式（普通）

package top.simba1949.factory.simple.commonFactory;

import top.simba1949.factory.simple.pizza.CheesePizza;
import top.simba1949.factory.simple.pizza.GreekPizza;
import top.simba1949.factory.simple.pizza.Pizza;

/**
 * @author anthony
 * @datetime 2023/7/15 13:19
 */
public class SimpleFactoryByCommon {

    public Pizza orderPizza(String type) {
        Pizza pizza=null;

        if ("cheese".equalsIgnoreCase(type)) {
            pizza=new CheesePizza();
            pizza.setName("cheese");
        } else if ("greek".equalsIgnoreCase(type)) {
            pizza=new GreekPizza();
            pizza.setName("greek");
        }

        if (null !=pizza){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }

        return pizza;
    }
}

測試類

package top.simba1949.factory.simple;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.simple.commonFactory.SimpleFactoryByCommon;
import top.simba1949.factory.simple.pizza.Pizza;
import top.simba1949.factory.simple.staticFacotry.SimpleFactoryByStatic;

/**
 * @author anthony
 * @datetime 2020/5/9 13:50
 */
@Slf4j
public class SimpleFactoryApplication {
    public static void main(String[] args) {
        String pizzaType="cheese";

        // 簡單工廠（靜態(tài)）模式
        // simpleFactoryByStatic(pizzaType);

        // 簡單工廠（普通）模式
        simpleFactoryByCommon(pizzaType);
    }

    public static void simpleFactoryByStatic(String pizzaType){
        // 用戶訂購 Pizza
        Pizza pizza=SimpleFactoryByStatic.orderPizza(pizzaType);
        // 得到 Pizza
        log.info("簡單工廠（靜態(tài)）：訂購的披薩是{}", pizza);
    }

    public static void simpleFactoryByCommon(String pizzaType){
        SimpleFactoryByCommon simpleFactoryByCommon=new SimpleFactoryByCommon();
        // 用戶訂購 Pizza
        Pizza pizza=simpleFactoryByCommon.orderPizza(pizzaType);
        // 得到 Pizza
        log.info("簡單工廠（普通）：訂購的披薩是{}", pizza);
    }
}

工廠方法模式

工廠方法模式：定義了一個創(chuàng)建對象的抽象方法，由子類決定要實例化的類。
工程方法模式將對象的實例化推遲到子類實例化。

工廠方法模式的主要角色

• 抽象工廠：提供了創(chuàng)建產(chǎn)品的接口，調(diào)用者通過它訪問到具體工廠的工廠方法來創(chuàng)建產(chǎn)品；
• 具體工廠：主要是實現(xiàn)抽象工廠的抽象方法，完成具體產(chǎn)品的創(chuàng)建；
• 抽象產(chǎn)品：定義了產(chǎn)品的規(guī)范，描述了產(chǎn)品的主要特征和功能；
• 具體產(chǎn)品：實現(xiàn)類抽象產(chǎn)品所定義的接口，有具體工廠來創(chuàng)建，它同具體工廠一一對應(yīng)；

工廠方法模式優(yōu)缺點

優(yōu)點

• 用戶只需要知道具體工廠的名稱就可以得到所要的產(chǎn)品，無需知道產(chǎn)品的具體創(chuàng)建過程；
• 在系統(tǒng)增加新產(chǎn)品時只需要添加具體產(chǎn)品類和對應(yīng)的具體工廠類，無需對原工廠進(jìn)行任何修改，滿足開閉原則。

缺點

• 每增加一個產(chǎn)品就要增加一個具體產(chǎn)品類和一個對應(yīng)的具體工廠類增加了系統(tǒng)的復(fù)雜化度。產(chǎn)生類爆炸；

工廠方法模式的實現(xiàn)

UML 類圖描述

咖啡類

package top.simba1949.factory.method.coffee;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2023/7/15 13:46
 */
@Slf4j
@Data
public abstract class Coffee {

    private String name;

    public void addMilk(){
        log.info("{} 添加了牛奶", name);
    }

    public void addSugar(){
        log.info("{} 添加了糖", name);
    }
}

package top.simba1949.factory.method.coffee;

/**
 * @author anthony
 * @datetime 2023/7/15 13:51
 */
public class AmericanoCoffee extends Coffee {
}

package top.simba1949.factory.method.coffee;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2023/7/15 13:53
 */
@Slf4j
@Data
public class LatteCoffee extends Coffee {
}

工廠類

package top.simba1949.factory.method.factory;

import top.simba1949.factory.method.coffee.Coffee;

/**
 * @author anthony
 * @datetime 2023/7/15 13:48
 */
public abstract class CoffeeFactory {
    
    public abstract Coffee createCoffee();
}

package top.simba1949.factory.method.factory;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.method.coffee.AmericanoCoffee;
import top.simba1949.factory.method.coffee.Coffee;

/**
 * @author anthony
 * @datetime 2023/7/15 13:49
 */
@Slf4j
public class AmericanoCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        Coffee coffee=new AmericanoCoffee();
        coffee.setName("美式咖啡");
        return coffee;
    }
}

package top.simba1949.factory.method.factory;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.method.coffee.Coffee;
import top.simba1949.factory.method.coffee.LatteCoffee;

/**
 * @author anthony
 * @datetime 2023/7/15 13:49
 */
@Slf4j
public class LatteCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        Coffee coffee=new LatteCoffee();
        coffee.setName("拿鐵咖啡");

        return coffee;
    }
}

咖啡店

package top.simba1949.factory.method;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.method.coffee.Coffee;
import top.simba1949.factory.method.factory.CoffeeFactory;

/**
 * @author anthony
 * @datetime 2023/7/15 13:52
 */
@Slf4j
@Data
public class CoffeeStore {

    public CoffeeFactory coffeeFactory;

    public Coffee orderCoffee(){
        // 這里創(chuàng)建對應(yīng)的對象
        Coffee coffee=coffeeFactory.createCoffee();

        coffee.addMilk();
        coffee.addSugar();

        return coffee;
    }
}

測試類

package top.simba1949.factory.method;


import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.method.coffee.Coffee;
import top.simba1949.factory.method.factory.AmericanoCoffeeFactory;
import top.simba1949.factory.method.factory.CoffeeFactory;

/**
 * @author anthony
 * @datetime 2020/5/9 14:30
 */
@Slf4j
public class MethodFactoryApplication {

    public static void main(String[] args) {
        // 創(chuàng)建咖啡店對象
        CoffeeStore coffeeStore=new CoffeeStore();
        // 創(chuàng)建工廠對象
        CoffeeFactory coffeeFactory=new AmericanoCoffeeFactory();
        coffeeStore.setCoffeeFactory(coffeeFactory);
        // 訂購咖啡
        Coffee coffee=coffeeStore.orderCoffee();
        log.info("訂購的咖啡是：{}", coffee);
    }
}

抽象工廠模式

是一種為訪問類提供一個創(chuàng)建一組相關(guān)或者相互依賴對象的接口，且訪問類無須指定所要產(chǎn)品的具體類就能得到同組的不同等級的產(chǎn)品的模式結(jié)構(gòu)。
抽象工廠模式是工廠方法模式的升級版本，工廠方法模式只生產(chǎn)一個等級的產(chǎn)品，而抽象工廠可生產(chǎn)多個等級的產(chǎn)品。

抽象工廠模式的主要角色

• 抽象工廠：提供了創(chuàng)建產(chǎn)品的接口，它包含多個創(chuàng)建產(chǎn)品的方法，可以創(chuàng)建多個不同等級的產(chǎn)品；
• 具體工廠：主要是實現(xiàn)抽象工廠中的多個抽象方法，完成具體產(chǎn)品的創(chuàng)建；
• 抽象產(chǎn)品：定義了產(chǎn)品的規(guī)范，描述了產(chǎn)品的主要特征和功能，抽象工廠模式有多個抽象產(chǎn)品；
• 具體產(chǎn)品：實現(xiàn)了抽象產(chǎn)品角色所定義的接口，由具體工廠創(chuàng)建，它同具體工廠是多對一的關(guān)系；

抽象工廠模式的優(yōu)缺點

優(yōu)點

當(dāng)一個產(chǎn)品族中的多個對象被設(shè)計成一起工作時，他能保證客戶端始終只使用同一個產(chǎn)品族中的對象；

缺點

當(dāng)產(chǎn)品族中需要新增一個新的產(chǎn)品，所有的工廠類都需要進(jìn)行修改；

使用場景

• 當(dāng)需要創(chuàng)建的對象是一系列相互關(guān)聯(lián)或相互依賴的產(chǎn)品族時，如電器工廠中的電視機、洗衣機、空調(diào)等。
• 系統(tǒng)中有多個產(chǎn)品族，但每次只使用其中的某一族產(chǎn)品。如有人只喜歡穿某一個品牌的衣服和鞋。
• 系統(tǒng)中提供了產(chǎn)品的類庫，且所有產(chǎn)品的接口相同，客戶端不依賴產(chǎn)品實例的創(chuàng)建細(xì)節(jié)和內(nèi)部結(jié)構(gòu)。

如：輸入法換皮膚，一整套一起換。生成不同操作系統(tǒng)的程序。

抽象工廠模式的實現(xiàn)

UML

甜點

package top.simba1949.factory.abs.dessert;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2023/7/15 14:25
 */
@Slf4j
@Data
public abstract class Dessert {

    private String name;

    public void show() {
        log.info("正在展示的甜點是{}", name);
    }
}

package top.simba1949.factory.abs.dessert;

/**
 * 抹茶慕斯
 *
 * @author anthony
 * @datetime 2023/7/15 14:28
 */
public class MatchaMousseDessert extends Dessert{
}

package top.simba1949.factory.abs.dessert;

/**
 * 提拉米蘇
 *
 * @author anthony
 * @datetime 2023/7/15 14:26
 */
public class TiramisuDessert extends Dessert {
}

咖啡

package top.simba1949.factory.abs.coffee;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * @author anthony
 * @datetime 2023/7/15 14:26
 */
@Slf4j
@Data
public abstract class Coffee {

    private String name;

    public void addMilk(){
        log.info("{} 添加了牛奶", name);
    }

    public void addSugar(){
        log.info("{} 添加了糖", name);
    }
}

package top.simba1949.factory.abs.factory;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.abs.coffee.AmericanoCoffee;
import top.simba1949.factory.abs.coffee.Coffee;
import top.simba1949.factory.abs.dessert.Dessert;
import top.simba1949.factory.abs.dessert.MatchaMousseDessert;

/**
 * @author anthony
 * @datetime 2023/7/15 14:32
 */
@Slf4j
public class AmericanFactory extends AbsFactory {

    @Override
    public Coffee createCoffee() {
        Coffee coffee=new AmericanoCoffee();
        coffee.setName("美式咖啡");
        coffee.addSugar();
        return coffee;
    }

    @Override
    public Dessert createDessert() {
        Dessert dessert=new MatchaMousseDessert();
        dessert.setName("抹茶慕斯");
        return dessert;
    }
}

package top.simba1949.factory.abs.factory;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.abs.coffee.Coffee;
import top.simba1949.factory.abs.coffee.LatteCoffee;
import top.simba1949.factory.abs.dessert.Dessert;
import top.simba1949.factory.abs.dessert.TiramisuDessert;

/**
 * @author anthony
 * @datetime 2023/7/15 14:32
 */
@Slf4j
public class ItalyFactory extends AbsFactory {

    @Override
    public Coffee createCoffee() {
        Coffee coffee=new LatteCoffee();
        coffee.setName("拿鐵咖啡");
        coffee.addMilk();
        return coffee;
    }

    @Override
    public Dessert createDessert() {
        Dessert dessert=new TiramisuDessert();
        dessert.setName("提拉米蘇");
        return dessert;
    }
}

工廠

package top.simba1949.factory.abs.factory;

import top.simba1949.factory.abs.coffee.Coffee;
import top.simba1949.factory.abs.dessert.Dessert;

/**
 * @author anthony
 * @datetime 2023/7/15 14:31
 */
public abstract class AbsFactory {

    public abstract Coffee createCoffee();

    public abstract Dessert createDessert();
}

package top.simba1949.factory.abs.factory;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.abs.coffee.AmericanoCoffee;
import top.simba1949.factory.abs.coffee.Coffee;
import top.simba1949.factory.abs.dessert.Dessert;
import top.simba1949.factory.abs.dessert.MatchaMousseDessert;

/**
 * @author anthony
 * @datetime 2023/7/15 14:32
 */
@Slf4j
public class AmericanFactory extends AbsFactory {

    @Override
    public Coffee createCoffee() {
        Coffee coffee=new AmericanoCoffee();
        coffee.setName("美式咖啡");
        coffee.addSugar();
        return coffee;
    }

    @Override
    public Dessert createDessert() {
        Dessert dessert=new MatchaMousseDessert();
        dessert.setName("抹茶慕斯");
        return dessert;
    }
}

package top.simba1949.factory.abs.factory;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.abs.coffee.Coffee;
import top.simba1949.factory.abs.coffee.LatteCoffee;
import top.simba1949.factory.abs.dessert.Dessert;
import top.simba1949.factory.abs.dessert.TiramisuDessert;

/**
 * @author anthony
 * @datetime 2023/7/15 14:32
 */
@Slf4j
public class ItalyFactory extends AbsFactory {

    @Override
    public Coffee createCoffee() {
        Coffee coffee=new LatteCoffee();
        coffee.setName("拿鐵咖啡");
        coffee.addMilk();
        return coffee;
    }

    @Override
    public Dessert createDessert() {
        Dessert dessert=new TiramisuDessert();
        dessert.setName("提拉米蘇");
        return dessert;
    }
}

測試

package top.simba1949.factory.abs;

import lombok.extern.slf4j.Slf4j;
import top.simba1949.factory.abs.coffee.Coffee;
import top.simba1949.factory.abs.dessert.Dessert;
import top.simba1949.factory.abs.factory.ItalyFactory;

/**
 * @author anthony
 * @datetime 2023/7/15 14:37
 */
@Slf4j
public class AbsFactoryApplication {

    public static void main(String[] args) {
        ItalyFactory italyFactory=new ItalyFactory();

        Coffee coffee=italyFactory.createCoffee();
        log.info("訂購的咖啡是：{}", coffee);

        Dessert dessert=italyFactory.createDessert();
        log.info("訂購的甜品是：{}", dessert);
    }
}

JDK 源碼中的工廠模式