工廠模式總結——三個工廠

来源:https://www.cnblogs.com/xiaobaiLX/archive/2022/09/24/16725442.html
-Advertisement-
Play Games

在創建型模式中，工廠模式是我們日常使用最為頻繁的設計模式之一。工廠模式可細分為簡單工廠模式、工廠方法模式、抽象工廠模式。 簡單工廠模式 模式簡介 簡單工廠模式：根據參數返回不同類的實例，這些類通常具有共同的父類。 簡單工廠模式包括三個角色： 工廠 (Factory)：用於創建所需產品，提供靜態工廠方 ...


在創建型模式中，工廠模式是我們日常使用最為頻繁的設計模式之一。工廠模式可細分為簡單工廠模式、工廠方法模式、抽象工廠模式。

簡單工廠模式

模式簡介

簡單工廠模式：根據參數返回不同類的實例，這些類通常具有共同的父類。

簡單工廠模式包括三個角色：

  1. 工廠 (Factory)：用於創建所需產品，提供靜態工廠方法，返回抽象產品類型 Product；
  2. 抽象產品 (Product)：是工廠創建的所有對象的父類，封裝了各種共有方法；
  3. 具體產品 (ConcreateProduct)：工廠創建目標，繼承抽象產品，實現了抽象產品的抽象方法。

應用實例

image-20220911203830271

  1. 工廠——FruitFactory

    public class FruitFactory {

    public static Object createFruit(String clazzName)  throws Exception{
        Object obj = null;
        if (clazzName.equals(Apple.class.getName())){
            obj = new Apple();
        } else if (clazzName.equals(Strawberry.class.getName())){
            obj = new Strawberry();
        } else if (clazzName.equals(Banana.class.getName())){
            obj = new Banana();
        } else {
            throw new ClassNotFoundException("沒有找到該類");
        }
        return obj;
    }

    //升級簡化版
    /*public static Object create(String clazzName) throws Exception{
        Object obj = null;
        Class clazz = Class.forName(clazzName);
        if (clazz.isAssignableFrom(Fruit.class)){
            obj = clazz.newInstance();
        } else {
            throw new ClassNotFoundException("沒有找到該類");
        }
        return obj;
    }*/
}

  2. 抽象產品——Fruit

    public abstract class Fruit {
    public abstract void getInfo();
}

  3. 具體產品——Apple、Banana、Strawberry

    • Apple
    public class Apple extends Fruit{
    @Override
    public void getInfo() {
        System.out.println("這是一個砸中牛頓腦袋的蘋果");
    }
}
    • Banana
    public class Banana extends Fruit{
    @Override
    public void getInfo() {
        System.out.println("這是一根讓猶太人致富的香蕉");
    }
}
    • Strawberry
    public class Strawberry extends Fruit{
    @Override
    public void getInfo() {
        System.out.println("這是一顆甜到你心裡的草莓");
    }
}

  4. 客戶端

    public class MainTest {
    public static void main(String[] args) throws Exception {
        //要個蘋果
        Apple apple = (Apple) FruitFactory.createFruit(Apple.class.getName());
        apple.getInfo();
        //要顆草莓
        Strawberry strawberry = (Strawberry) FruitFactory.createFruit(Strawberry.class.getName());
        strawberry.getInfo();
        //要根香蕉
        Banana banana = (Banana) FruitFactory.createFruit(Banana.class.getName());
        banana.getInfo();
    }
}

模式總結

優點：實現簡單，屏蔽了對象創建過程，實現了對象創建和使用的分離。

缺點：集中了所有產品創建邏輯，職責過重；擴展困難，一旦添加類需修改源碼；使用靜態工廠方法，工廠角色無法形成繼承結構。

使用場景：工廠負責創建對象較少。

工廠方法模式

模式簡介

工廠方法模式：定義了一個用於創建對象的介面，但是讓子類決定將哪個類實例化。工廠方法讓一個類的實例化延遲到了子類。

工廠方法模式在簡單工廠模式的基礎上，引入了抽象工廠，將具體產品的創建延遲到了具體工廠，剋服了簡單工廠模式職責過重的缺點。

工廠方法模式包括了 4 個角色：

  1. 抽象工廠（AbstractFactory）：定義了抽象工廠方法，用於返回一個產品，具體返回哪類產品由具體工廠決定。
  2. 抽象產品（AbstractProduct）：是所有具體產品的公共父類，定義了產品的介面。
  3. 具體工廠（ConcreteFactory）：是抽象工廠的子類，實現了抽象工廠的工廠方法，返回一個具體產品。
  4. 具體產品（ConcreteProduct）：實現了抽象產品介面，由具體工廠創建。

應用實例

image-20220911203219104

  1. 抽象工廠——FruitFactory

    public abstract class FruitFactory {
    public abstract Fruit createFruit();
}

  2. 抽象產品——Fruit

    public abstract class Fruit {
    public abstract void getInfo();
}

  3. 具體工廠——AppleFactory、BananaFactory、StrawberryFactory

    • AppleFactory
    public class AppleFactory extends FruitFactory{

    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}
    • BananaFactory
    public class BananaFactory extends FruitFactory{

    @Override
    public Fruit createFruit() {
        return new Banana();
    }
}
    • StrawberryFactory
    public class StrawberryFactory extends FruitFactory{

    @Override
    public Fruit createFruit() {
        return new Strawberry();
    }
}

  4. 具體產品——Apple、Banana、Strawberry

    • Apple
    public class Apple extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一個砸中牛頓腦袋的蘋果");
    }
}
    • Banana
    public class Banana extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一根讓猶太人致富的香蕉");
    }
}
    • Strawberry
    public class Strawberry extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一顆甜到你心裡的草莓");
    }
}

  5. 客戶端

    public class MainTest {
    public static void main(String[] args) throws Exception {
        FruitFactory factory = null;
        //要個蘋果
        factory = new AppleFactory();
        Fruit apple = factory.createFruit();
        apple.getInfo();
        //要顆草莓
        factory = new StrawberryFactory();
        Fruit strawberry = factory.createFruit();
        strawberry.getInfo();
        //要根香蕉
        factory = new BananaFactory();
        Fruit banana = factory.createFruit();
        banana.getInfo();
    }
}

模式總結

優點

  1. 隱藏了對象創建細節，用戶創建對象時無需知道具體類名，只需知道相應的工廠類即可創建相應類對象。
  2. 在系統中添加新的產品時不會對現有代碼產生影響，具有良好的擴展性，符合開閉原則。

缺點

  1. 每個產品需要添加對應的具體工廠類，類的數量因此成對增加，增加了系統複雜性和性能消耗。
  2. 引入了抽象層，增加了系統的抽象性和理解難度。

使用場景

  1. 客戶端不需要知道它所需創建的類對象的類名；
  2. 抽象類通過子類來指定創建具體哪個類的對象。

抽象工廠模式

模式簡介

抽象工廠：提供一個創建一系列相關或相關以來對象的介面，從而無需指定他們具體的類。

兩個概念

產品等級結構：即產品的繼承結構，水果是個抽象類，其子類包括蘋果、香蕉、草莓，則抽象類與具體類之間構成了一個產品等級結構。

產品族：在抽象工廠模式中，產品族是同一個工廠生產的不同產品等級結構中的一組產品。例如當前有兩個生產水果的工廠A和B都生產水果蘋果、香蕉、草莓，則工廠A生產的蘋果、香蕉、草莓構成一個產品族。

抽象工廠模式與工廠方法模式的區別在於，工廠方法模式針對的是一個產品等級結構，每一個具體工廠只能創建一個產品；而抽象工廠模式針對的是多個產品等級結構，其每個具體工廠負責創建一族的產品。

抽象工廠模式包括了 4 個角色：

  1. 抽象工廠（AbstractFactory）：聲明瞭一組用於創建一族產品的方法，每個方法對應一種產品。
  2. 抽象產品（AbstractProduct）：為每種產品聲明介面，在抽象產品中聲明瞭產品所具有的業務方法。
  3. 具體工廠（ConcreteFactory）：實現了抽象工廠中聲明的創建產品的方法，生成了一組具體產品，這些具體產品構成了一個產品族，每個產品位於某個產品等級結構中。
  4. 具體產品（ConcreteProduct）：實現了抽象產品介面，由具體工廠創建。

應用實例

image-20220911202602724

  1. 抽象工廠——FruitFactory

    public abstract class FruitFactory {

    public abstract Fruit createApple();

    public abstract Fruit createBanana();

    public abstract Fruit createStrawberry();

}

  2. 抽象產品

    public abstract class Fruit {
    public abstract void getInfo();
}

  3. 具體工廠——FruitFactoryA、FruitFactoryB

    • FruitFactoryA
    public class FruitFactoryA extends FruitFactory {
    
    @Override
    public Fruit createApple() {
        return new AppleA();
    }

    @Override
    public Fruit createBanana() {
        return new BananaA();
    }

    @Override
    public Fruit createStrawberry() {
        return new StrawberryA();
    }
}
    • FruitFactoryB
    public class FruitFactoryB extends FruitFactory {

    @Override
    public Fruit createApple() {
        return new AppleB();
    }

    @Override
    public Fruit createBanana() {
        return new BananaB();
    }

    @Override
    public Fruit createStrawberry() {
        return new StrawberryB();
    }
}

  4. 具體產品AppleA、AppleB、BananaA、BananaB、StrawberryA、StrawberryB

    • AppleA
    public class AppleA extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一個砸中牛頓腦袋的蘋果，由工廠A生產");
    }
}
    • AppleB
    public class AppleB extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一個砸中牛頓腦袋的蘋果，由工廠B生產");
    }
}
    • BananaA
    public class BananaA extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一根讓猶太人致富的香蕉，由工廠A生產");
    }
}
    • BananaB
    public class BananaB extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一根讓猶太人致富的香蕉，由工廠B生產");
    }
}
    • StrawberryA
    public class StrawberryA extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一顆甜到你心裡的草莓，由工廠A生產");
    }
}
    • StrawberryB
    public class StrawberryB extends Fruit {
    @Override
    public void getInfo() {
        System.out.println("這是一顆甜到你心裡的草莓，由工廠B生產");
    }
}

  5. 客戶端

    public class MainTest {
    public static void main(String[] args) throws Exception {
        FruitFactory factoryA = new FruitFactoryA();
        FruitFactory factoryB = new FruitFactoryA();
        //要個蘋果
        Fruit appleA = factoryA.createApple();
        appleA.getInfo();
        Fruit appleB = factoryB.createApple();
        appleB.getInfo();
        //要顆草莓
        Fruit strawberryA = factoryA.createStrawberry();
        strawberryA.getInfo();
        Fruit strawberryB = factoryA.createStrawberry();
        strawberryB.getInfo();
        //要根香蕉
        Fruit bananaA = factoryA.createStrawberry();
        bananaA.getInfo();
        Fruit bananaB = factoryA.createStrawberry();
        bananaB.getInfo();
    }
}

模式總結

優點

  1. 隔離了具體類的生成，更換一個具體工廠就可以在某種程度上改變整個軟體系統行為。
  2. 當一個產品族的多個對象被設計成一起工作時，能夠保證客戶始終只是用同一個產品族中的對象。
  3. 添加新的產品無需修改已有代碼，符合開閉原則。

缺點

  1. 添加新的產品等級結構需要對原有系統進行較大修改，違背了開閉原則。

使用場景

  1. 系統有過個產品族，而每次使用只使用其中一個產品族；
  2. 產品等級結構穩定，設計完成後不會對系統增加或刪除的產品等級結構。

工廠模式總結

  1. 簡單工廠模式隱藏了對象創建細節，將象創建過程與系統業務分離，只需傳入響應參數即可獲得相應對象，缺點是職責過重。
  2. 工廠方法模式引入了抽象工廠，剋服了簡單工廠模式的缺點，將具體對象創建延遲到了子類且可以靈活擴展，但一定程度上造成了系統的類數量膨脹，損耗系統性能。
  3. 抽象工廠模式在工廠方法模式的基礎上進一步擴展，每個具體工廠負責創建多個產品等級結構，減小了工廠方法模式造成的類膨脹問題，提供了系統效率。但是，抽象工廠模式存在開閉原則的傾向性，適用於只需擴展產品族，而產品登記結構穩定的系統。

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Bootstrap 筆記
    react腳手架創建幾種方式 node v16.17.0 npm 8.15.0 yarn 3.2.3 vite 3.1.3 配置less-loader npm 首先通過 npm 方式全局安裝 create-react-app npm install -g create-react-app 查看是否安 ...
  • 【前端必會】HtmlWebpackPlugin 和 SplitChunksPlugin 是什麼？
    ==面試題 ##1.vue2中的響應式原理簡述 響應式原理主要就是通過數據劫持，依賴收集，派發更新的方式來實現的 1.數據劫持，vue2是通過Object.defineProperty方法的get、set來將對對象進行遞歸劫持。 其中修改對象的屬性時 就會觸發set， 使用對象的屬性時就會觸發get ...
  • 前端ES6 面試過關寶典
    ES6 部分 Typescript 部分 前端工程面經（節流防抖、https、前端攻擊、性能優化...） https://juejin.cn/post/6844903734464495623 ES6面試 為什麼選擇 ES6 ？ ES6是新一代的 JS 語言標準，規範了JS的使用標準（var標量提升） ...
  • jQuery 筆記
    問題：【Chrome插件 Chrome extension 】報錯 Unchecked runtime.lastError: Could not establish connection. Receiving end does not exist. 在看一個別人插件的時候發現一個如上所述的報錯，雖然 ...
  • 微服務設計（四）---微服務網關與鏈路追蹤
    一、微服務網關概述 如下圖： 不同的微服務一般會有不同的網路地址，客戶端在訪問這些微服務時必須記住幾十甚至幾百個地址，這對於客戶端方來說太複雜也難以維護。如果讓客戶端直接與各個微服務通訊，可能會有很多問題： 客戶端會請求多個不同的服務，需要維護不同的請求地址，增加開發難度 在某些場景下存在跨域請求的 ...
  • 微服務設計（三）---服務調用Feign及服務熔斷機制Hystrix
    一 、Ribbon概述 Netflixfa 發佈的一個負載均衡器，有助於控制HTTP和TCP客戶端行為。在SpringCloud中，Ribbon提供了客戶端負載均衡的功能，Ribbon自動從服務註冊中心Eureka中讀取到的服務提供者的列表信息（動態獲取服務列表方式），在調用服務節點提供的服務時，基 ...
  • 初識設計模式 - 原型模式
    簡介 對於大部分系統來說，創建對象包括申請記憶體、給成員變數賦值等過程，這些操作耗費的時間基本可以忽略不計。 如果對象中的數據需要經過複雜的計算才能得到（比如排序、計算哈希值），或者需要從 RPC、網路、資料庫、文件系統等非常慢速的 IO 中讀取，這其中耗費的時間有時是無法容忍的。 如果對象的創建成本 ...
  • 建造者模式（創建型）
    建造者模式 介紹 建造者模式註重的是部件構建的過程，意在通過一步一步地精確構造出一個複雜的對象。 可以將建造者模式理解為，假設我們有一個對象需要建立，這個對象是由多個組件（Component）組合而成，每個組件的建立都比較複雜，但運用組件來建立所需的組件對象非常簡單，所以我們就可以將構建複雜組件的步 ...
一周排行
    -Advertisement-
    Play Games
  • （開源）都進來！簡單易懂、功能強大的許可權+可視化流程管理系統
    1、預覽地址：http://139.155.137.144:9012 2、qq群:801913255 一、前言 隨著網路的發展，企業對於信息系統數據的保密工作愈發重視，不同身份、角色對於數據的訪問許可權都應該大相徑庭。 列如 1、不同登錄人員對一個數據列表的可見度是不一樣的，如數據列、數據行、數據按鈕 ...
  • 設計模式-C#實現簡單工廠模式
    前言 上一篇文章寫瞭如何使用RabbitMQ做個簡單的發送郵件項目，然後評論也是比較多，也是準備去學習一下如何確保RabbitMQ的消息可靠性，但是由於時間原因，先來說說設計模式中的簡單工廠模式吧！ 在瞭解簡單工廠模式之前，我們要知道C#是一款面向對象的高級程式語言。它有3大特性，封裝、繼承、多態。 ...
  • Nodify學習 一：介紹與使用
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 介紹 Nodify是一個WPF基於節點的編輯器控制項，其中包含一系列節點、連接和連接器組件，旨在簡化構建基於節點的工具的過程 ...
  • 使用C#/.NET解析Wiki百科數據實現獲取歷史上的今天
    創建一個webapi項目做測試使用。 創建新控制器，搭建一個基礎框架，包括獲取當天日期、wiki的請求地址等 創建一個Http請求幫助類以及方法，用於獲取指定URL的信息 使用http請求訪問指定url，先運行一下，看看返回的內容。內容如圖右邊所示，實際上是一個Json數據。我們主要解析 大事記 部 ...
  • .NET科普：.NET簡史、.NET Standard以及C#和.NET Framework之間的關係
    最近在不少自媒體上看到有關.NET與C#的資訊與評價，感覺大家對.NET與C#還是不太瞭解，尤其是對2016年6月發佈的跨平臺.NET Core 1.0，更是知之甚少。在考慮一番之後，還是決定寫點東西總結一下，也回顧一下.NET的發展歷史。 首先，你沒看錯，.NET是跨平臺的，可以在Windows、 ...
  • Nodify學習 二：添加節點
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 添加節點（nodes） 通過上一篇我們已經創建好了編輯器實例現在我們為編輯器添加一個節點 添加model和viewmode ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（上）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
  • C# 使用模式匹配的好處,因為好用所以推薦~
    類型檢查和轉換：當你需要檢查對象是否為特定類型，並且希望在同一時間內將其轉換為那個類型時，模式匹配提供了一種更簡潔的方式來完成這一任務，避免了使用傳統的as和is操作符後還需要進行額外的null檢查。 複雜條件邏輯：在處理複雜的條件邏輯時，特別是涉及到多個條件和類型的情況下，使用模式匹配可以使代碼更 ...
  • 推薦一種批量判斷文件是否存在的快速辦法
    在日常開發中，我們經常需要和文件打交道，特別是桌面開發，有時候就會需要載入大批量的文件，而且可能還會存在部分文件缺失的情況，那麼如何才能快速的判斷文件是否存在呢？如果處理不當的，且文件數量比較多的時候，可能會造成卡頓等情況，進而影響程式的使用體驗。今天就以一個簡單的小例子，簡述兩種不同的判斷文件是否... ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（中）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
所有分類