一個工廠還能寫出花來？

来源:http://www.cnblogs.com/snaildev/archive/2017/09/26/7598230.html
-Advertisement-
Play Games

簡單工廠模式 工廠模式 抽象工廠模式 簡單工廠模式 工廠模式 抽象工廠模式 簡單工廠模式 什麼是簡單工廠模式？ 在現實生活中工廠是負責生產產品的,同樣在設計模式中,簡單工廠模式我們也可以理解為負責生產對象的一個類, 我們平常編程中，當使用"new"關鍵字創建一個對象時，此時該類就依賴與這個對象，也就 ...


  • 簡單工廠模式

  • 工廠模式

  • 抽象工廠模式

簡單工廠模式

什麼是簡單工廠模式？

在現實生活中工廠是負責生產產品的,同樣在設計模式中,簡單工廠模式我們也可以理解為負責生產對象的一個類, 我們平常編程中，當使用"new"關鍵字創建一個對象時，此時該類就依賴與這個對象，也就是他們之間的耦合度高，當需求變化時，我們就不得不去修改此類的源碼，此時我們可以運用面向對象（OO）的很重要的原則去解決這一的問題，該原則就是——封裝改變，既然要封裝改變，自然也就要找到改變的代碼，然後把改變的代碼用類來封裝，這樣的一種思路也就是我們簡單工廠模式的實現方式了。下麵通過一個 現實生活中的例子來引出簡單工廠模式。

一般情況下，如果我們想開什麼車，只能自己去買，但是如今已是共用經濟的時代，小到雨傘，中到自行車、電動自行車，大到汽車，如今都可以以租賃的形式使用。租車公司停了幾輛車（奇瑞、路虎、蘭博基尼），根據客戶不同的意願，租出去的車是不一樣的，但是車都是在租車公司里有的。車都屬於同一種抽象，租車公司里所有的車都有自己的特征，這些特征就是條件。租車公司根據客戶不同的租車意願，會租出不同的車。這就簡單工廠模式的典型案例。

/// <summary>
/// 汽車類型
/// </summary>
public enum CarType
{
    /// <summary>
    /// 奇瑞
    /// </summary>
    Chery = 0,

    /// <summary>
    /// 路虎
    /// </summary>
    LandRover = 1,

    /// <summary>
    /// 蘭博基尼
    /// </summary>
    Lambo = 2
}

/// <summary>
/// 汽車抽象類
/// </summary>
public abstract class Car
{
    /// <summary>
    /// 輸出自己是什麼車
    /// </summary>
    public abstract void Print();
}

/// <summary>
/// 奇瑞汽車
/// </summary>
public class CheryCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌是奇瑞");
    }
}

/// <summary>
/// 蘭博基尼
/// </summary>
public class LamboCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌是蘭博基尼");
    }
}

/// <summary>
/// 路虎
/// </summary>
public class LandRoverCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌路虎");
    }
}

/// <summary>
/// 簡單工廠
/// </summary>
public class SimpleFactory
{
    public static Car GetCar(CarType type)
    {
        switch (type)
        {
            case CarType.Chery:
                return new CheryCar();
            case CarType.LandRover:
                return new LandRoverCar();
            case CarType.Lambo:
                return new LamboCar();
            default:
                throw new Exception("未找到相應品牌汽車");
        }
    }
}

/// </summary>
/// 調用
/// </summary>
static void Main(string[] args)
{
    // 開蘭博基尼
    Car car1 = SimpleFactory.GetCar(CarType.Lambo);
    car1.Print();
	
    // 開路虎
    Car car2 = SimpleFactory.GetCar(CarType.LandRover);
    car2.Print();

    Console.Read();
}

簡單工廠模式的優缺點

看完簡單工廠模式的實現之後，你和你的小伙伴們肯定會有這樣的疑惑（因為我學習的時候也有）——這樣我們只是把變化移到了工廠類中罷了，好像沒有變化的問題，因為如果客戶想租其他車時，此時我們還是需要修改工廠類中的方法（也就是多加case語句，沒應用簡單工廠模式之前，修改的是客戶類）。我首先要說：你和你的小伙伴很對，這個就是簡單工廠模式的缺點所在（這個缺點後面介紹的工廠方法可以很好地解決），然而，簡單工廠模式與之前的實現也有它的優點：

  • 簡單工廠模式解決了客戶端直接依賴於具體對象的問題，客戶端可以消除直接創建對象的責任，而僅僅是消費產品。簡單工廠模式實現了對責任的分割；
  • 簡單工廠模式也起到了代碼復用的作用，所有客戶有用車需求時，都不需要自己買車，只需要負責消費就可以了。此時簡單工廠的租車方法就讓所有客戶共用了。（同時這點也是簡單工廠方法的缺點——因為工廠類集中了所有產品創建邏輯，一旦不能正常工作，整個系統都會受到影響，也沒什麼不好理解的，就如事物都有兩面性一樣道理。

雖然上面已經介紹了簡單工廠模式的缺點，下麵還是總結下簡單工廠模式的缺點：

  • 工廠類集中了所有產品創建邏輯，一旦不能正常工作，整個系統都會受到影響（通俗地意思就是：一旦租車公司沒車或者關門了，很多不願意買車的人就沒車開了）
  • 系統擴展困難，一旦添加新產品就不得不修改工廠邏輯，這樣就會造成工廠邏輯過於複雜。

簡單工廠的應用場景

  • 當工廠類負責創建的對象比較少時可以考慮使用簡單工廠模式
  • 客戶如果只知道傳入工廠類的參數，對於如何創建對象的邏輯不關心時可以考慮使用簡單工廠模式

工廠模式

什麼是工廠模式？


工廠方法模式之所以可以解決簡單工廠的模式，是因為它的實現把具體產品的創建推遲到子類中，此時工廠類不再負責所有產品的創建，而只是給出具體工廠必須實現的介面，這樣工廠方法模式就可以允許系統不修改工廠類邏輯的情況下來添加新產品，這樣也就剋服了簡單工廠模式中缺點。

/// <summary>
/// 汽車類型
/// </summary>
public enum CarType
{
    /// <summary>
    /// 奇瑞
    /// </summary>
    Chery = 0,

    /// <summary>
    /// 路虎
    /// </summary>
    LandRover = 1,

    /// <summary>
    /// 蘭博基尼
    /// </summary>
    Lambo = 2
}

/// <summary>
/// 汽車抽象類
/// </summary>
public abstract class Car
{
    /// <summary>
    /// 輸出自己是什麼車
    /// </summary>
    public abstract void Print();
}

/// <summary>
/// 奇瑞汽車
/// </summary>
public class CheryCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌是奇瑞");
    }
}

/// <summary>
/// 蘭博基尼
/// </summary>
public class LamboCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌是蘭博基尼");
    }
}

/// <summary>
/// 路虎
/// </summary>
public class LandRoverCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌路虎");
    }
}

/// <summary>
/// 汽車抽象工廠
/// </summary>
public abstract class CarFactory
{
    /// <summary>
    /// 生產汽車
    /// </summary>
    /// <returns></returns>
    public abstract Car CreateCar();
}

/// <summary>
/// 奇瑞工廠類
/// </summary>
public class CheryFactory : CarFactory
{
    /// <summary>
    /// 生產奇瑞汽車
    /// </summary>
    /// <returns></returns>
    public override Car CreateCar()
    {
        return new CheryCar();
    }
}

/// <summary>
/// 蘭博基尼工廠
/// </summary>
public class LamboFactory : CarFactory
{
    /// <summary>
    /// 生產汽車
    /// </summary>
    /// <returns></returns>
    public override Car CreateCar()
    {
        return new LamboCar();
    }
}

/// <summary>
/// 路虎工廠
/// </summary>
public class LandRoverFactory : CarFactory
{
    /// <summary>
    /// 生產汽車
    /// </summary>
    /// <returns></returns>
    public override Car CreateCar()
    {
        return new LandRoverCar();
    }
}

static void Main(string[] args)
{
    // 初始化生產汽車的兩個工廠
    CarFactory landRoverFactory = new LandRoverFactory();
    CarFactory lamboFactory = new LamboFactory();

    // 開始生產路虎
    Car landRover = landRoverFactory.CreateCar();
    landRover.Print();

    //開始生產蘭博基尼
    Car lambo = lamboFactory.CreateCar();
    lambo.Print();

    Console.Read();
}

使用工廠方法實現的系統，如果系統需要添加新產品時，我們可以利用多態性來完成系統的擴展，對於抽象工廠類和具體工廠中的代碼都不需要做任何改動。例如，我們我們還想要一個“奧迪汽車”，此時我們只需要定義一個奧迪汽車具體工廠類和奧迪汽車子類就可以。而不用像簡單工廠模式中那樣去修改工廠類中的實現（具體指添加case語句)。具體代碼為：

/// <summary>
/// 奧迪汽車
/// </summary>
public class AodiCar : Car
{
    /// <summary>
    /// 重寫抽象類中的方法
    /// </summary>
    public override void Print()
    {
        Console.WriteLine("我的品牌是奧迪");
    }
}

/// <summary>
/// 奧迪汽車工廠類，負責生產奧迪汽車
/// </summary>
public class AodiFactory : CarFactory
{
    /// <summary>
    /// 生產汽車
    /// </summary>
    /// <returns></returns>
    public override Car CreateCar()
    {
        return new AodiCar();
    }
}

/// <summary>
/// 調用
/// </summary>
static void Main(string[] args)
{
   
    // 如果客戶想租一輛奧迪車
    // 再另外初始化一個奧迪車工廠
    CarFactory aodiFactory = new AodiFactory();

    // 利用奧迪車工廠來生產奧迪汽車
    Car aodi = aodiFactory.CreateCar();
    aodi.Print();

    Console.Read();
}

工廠模式的優缺點

工廠方法模式通過面向對象編程中的多態性來將對象的創建延遲到具體工廠中，從而解決了簡單工廠模式中存在的問題，也很好地符合了開放封閉原則（即對擴展開發，對修改封閉）。
優點：

  • 子類提供掛鉤。基類為工廠方法提供預設實現，子類可以重寫新的實現，也可以繼承父類的實現。-- 加一層間接性，增加了靈活性
  • 屏蔽產品類。產品類的實現如何變化，調用者都不需要關心，只需關心產品的介面，只要介面保持不變，系統中的上層模塊就不會發生變化。
  • 典型的解耦框架。高層模塊只需要知道產品的抽象類，其他的實現類都不需要關心，符合迪米特法則，符合依賴倒置原則，符合里氏替換原則。
  • 多態性：客戶代碼可以做到與特定應用無關，適用於任何實體類。

缺點：需要指定工廠和相應的子類作為factory method的載體，如果應用模型確實需要指定工廠和子類存在，則很好；否則的話，需要增加一個類層次。(不過說這個缺點好像有點吹毛求疵了)

抽象工廠模式

什麼是抽象工廠模式？

工廠方法模式是為了剋服簡單工廠模式的缺點而設計出來的,簡單工廠模式的工廠類隨著產品類的增加需要增加額外的代碼，而工廠方法模式每個具體工廠類只完成單個實例的創建,所以它具有很好的可擴展性。但是在現實生活中，一個工廠只創建單個產品這樣的例子很少，因為現在的工廠都多元化了，一個工廠創建一系列的產品，如果我們要設計這樣的系統時，工廠方法模式顯然在這裡不適用，然後抽象工廠模式卻可以很好地解決一系列產品創建的問題。

/// <summary>
/// 汽車類型
/// </summary>
public enum CarType
{
    /// <summary>
    /// 奇瑞
    /// </summary>
    Chery = 0,

    /// <summary>
    /// 路虎
    /// </summary>
    LandRover = 1,

    /// <summary>
    /// 蘭博基尼
    /// </summary>
    Lambo = 2
}

/// <summary>
/// 汽車抽象類
/// </summary>
public abstract class Car
{
    /// <summary>
    /// 輸出自己是什麼車
    /// </summary>
    public abstract void Print();
}

/// <summary>
/// 奇瑞汽車
/// </summary>
public class CheryCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌是奇瑞");
    }
}

/// <summary>
/// 蘭博基尼
/// </summary>
public class LamboCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌是蘭博基尼");
    }
}

/// <summary>
/// 路虎
/// </summary>
public class LandRoverCar : Car
{
    public override void Print()
    {
        Console.WriteLine("我的品牌路虎");
    }
}

/// <summary>
/// 售後服務抽象類
/// </summary>
public abstract class CustomerService

{
    /// <summary>
    /// 列印售後服務
    /// </summary>
    public abstract void Print();
}

/// <summary>
/// 奇瑞售後服務
/// </summary>
public class CheryService : CustomerService
{
    public override void Print()
    {
        Console.WriteLine("我是奇瑞售後服務");
    }
}

/// <summary>
/// 蘭博基尼售後服務
/// </summary>
public class LamboService : CustomerService
{
    public override void Print()
    {
        Console.WriteLine("我是蘭博基尼售後服務");
    }
}

/// <summary>
/// 路虎售後服務
/// </summary>
public class LandRoverService : CustomerService
{
    public override void Print()
    {
        Console.WriteLine("我是路虎售後服務");
    }
}

/// <summary>
/// 抽象工廠類
/// </summary>
public abstract class AbstractFactory
{
    /// <summary>
    /// 生產汽車
    /// </summary>
    /// <returns></returns>
    public abstract Car CreateCar();

    /// <summary>
    /// 提供售後服務
    /// </summary>
    /// <returns></returns>
    public abstract CustomerService Service();
}

/// <summary>
/// 奇瑞抽象工廠類
/// </summary>
public class CheryAbFactory : AbstractFactory
{
    public override Car CreateCar()
    {
        return new CheryCar();
    }

    public override CustomerService Service()
    {
        return new CheryService();
    }
}

/// <summary>
/// 蘭博基尼抽象工廠
/// </summary>
public class LamboAbFactory : AbstractFactory
{
    public override Car CreateCar()
    {
        return new LamboCar();
    }

    public override CustomerService Service()
    {
        return new LamboService();
    }
}

/// <summary>
/// 路虎抽象工廠
/// </summary>
public class LandRoverAbFactory : AbstractFactory
{
    public override Car CreateCar()
    {
        return new LandRoverCar();
    }

    public override CustomerService Service()
    {
        return new LandRoverService();
    }
}

/// <summary>
/// 調用
/// </summary>
static void Main(string[] args)
{
    // 路虎汽車及售後
    AbstractFactory landRoverAbFactory = new LandRoverAbFactory();
    landRoverAbFactory.CreateCar().Print();
    landRoverAbFactory.Service().Print();

    // 蘭博基尼汽車及售後
    AbstractFactory lamboAbFactory = new LamboAbFactory();
    lamboAbFactory.CreateCar().Print();
    lamboAbFactory.Service().Print();

    Console.Read();
}

抽象工廠允許客戶使用抽象的介面來創建一組相關產品，而不需要知道或關心實際生產出的具體產品是什麼。這樣客戶就可以從具體產品中被解耦。
看完上面抽象工廠的實現之後，如果租車公司又加了一個品牌車奧迪怎麼辦呢？此時，只需要添加三個類：一個是奧迪具體工廠類，負責生產奧迪和提供售後服務，另外兩個類是奧迪售後服務類和奧迪車類。代碼就不贅述。

抽象工廠模式的優缺點

優點：抽象工廠模式將具體產品的創建延遲到具體工廠的子類中，這樣將對象的創建封裝起來，可以減少客戶端與具體產品類之間的依賴，從而使系統耦合度低，這樣更有利於後期的維護和擴展。
缺點：抽象工廠模式很難支持新種類產品的變化。這是因為抽象工廠介面中已經確定了可以被創建的產品集合，如果需要添加新產品，此時就必須去修改抽象工廠的介面，這樣就涉及到抽象工廠類的以及所有子類的改變，這樣也就違背了“開發——封閉”原則。

抽象工廠模式的使用前提

知道了抽象工廠的優缺點之後，也就能很好地把握什麼情況下考慮使用抽象工廠模式了，下麵就具體看看使用抽象工廠模式的系統應該符合那幾個前提：

  • 一個系統不要求依賴產品類實例如何被創建、組合和表達的表達，這點也是所有工廠模式應用的前提。
  • 這個系統有多個系列產品，而系統中只消費其中某一系列產品
  • 系統要求提供一個產品類的庫，所有產品以同樣的介面出現，客戶端不需要依賴具體實現。

總結

本文總結了三種工廠模式，逐層遞進，希望大家通過本文有所得。我們使用設計模式目的無非只有三個：a)縮短開發時間；b)降低維護成本；c)在應用程式之間和內部輕鬆集成，但是具體什麼時候使用何種設計模式還得因項目而異。

代碼


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

-Advertisement-
Play Games
更多相關文章
  • java之單例模式
    首先，先看個例子吧 上面的代碼，是典型的懶漢式單例模式，在單線程的情況下，完全是沒有問題的，但是在多線程的環境下，就很難保證對象的單例了。那應該如何去保證在多線程的環境下的單例呢？相信學過了，學過多線程的基本知識的都知道在可能會產生併發的地方，加上同步就好，即synchronized(同步方法或者同 ...
  • 解決Python 字典寫入文件出行首行有空格的解決方法
    模擬購物車程式，判斷用戶薪資是否是0 如果是0就需要輸入薪資，並記錄到文件內。 可以預先存個字典格式的字元串，然後去讀取文件的時候讀到的是字字元串然後再去用eval去轉換成字典。 當我們覆蓋寫到文件的時候就會發現首行會有空格，當我們再去讀取eval的時候就會報錯，那怎麼樣可以解決這個問題呢！ ...
  • TensorFlow學習---入門（一）-----MNIST機器學習
    參考教程：http://www.tensorfly.cn/tfdoc/tutorials/mnist_beginners.html 數據下載地址：http://wiki.jikexueyuan.com/project/tensorflow-zh/tutorials/mnist_download.ht ...
  • Java基礎——集合源碼解析 List List 介面
    今天我們來學習集合的第一大體系 List。 List 是一個介面，定義了一組元素是有序的、可重覆的集合。 List 繼承自 Collection，較之 Collection，List 還添加了以下操作方法 位置相關：List 的元素是有序的，因此有get(index)、set(index,objec ...
  • servlet 轉發、包含（七）
    1.什麼是servlet轉發？ servlet將用戶的請求通過一組servlet來處理，每個servlet都有自己特定的職責，當該servlet完成自己的工作後將請求轉發到下一個servlet來處理，這種通過不同servelet相互轉發請求來完成對某個請求的處理過程就叫做servlet轉發。 2.什 ...
  • python第一課
    本節內容 1.交互操作 2.變數 3.字元串 4.for迴圈、while迴圈 5.break語句、continue語句 1.交互操作 在cmd下的 開始--》cmd--》cd c:\ --》dir cd d:\=切換到d盤 cd=change directory dir=查看當前路徑下的文件 文件名 ...
  • Java構造函數、構造代碼塊和靜態代碼塊的區別和調用時間
    靜態代碼塊：最早執行， 類 被載入記憶體時執行，只執行一次。沒有名字、參數和返回值，有關鍵字static。 構造代碼塊：執行時間比靜態代碼塊晚，比構造函數早，和構造函數一樣，只在 對象 初始化的時候運行。沒有名字、參數和返回值。 構造函數：執行時間比構造代碼塊時間晚，也是在 對象 初始化的時候運行。沒 ...
  • 什麼才是java的基礎知識？
    初學者先廣在精，關註代碼背後的實現，關註內功修煉，瞭解實現原理和思想，形成自己完整的技術體系，知識成片之後就容易觸類旁通，進步的速度就會越來越快。最後以我在每一個項目組和開發人員聊天都會說的幾個例子結尾：“少林功夫裡面有功和拳之分，馬步功，石鎖功是功，蛇拳猴拳是拳，你不可能練會了蛇拳猴拳就能打人，你... ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類