設計模式--簡單工廠模式

最近又在看程傑的《大話設計模式》這本書，這真的是我超級喜歡的一本書，裏面的內容很精彩，學習之餘，將書中的內容整理出來，另外加上了一些自己的理解，方便日後自己回顧並同時希望本筆記可以對各位編程者有所幫助，相關技術上博主理解如有偏頗，還請指正。

簡單工廠模式是項目開發中最常用也是最重要的一種設計模式，幾乎在所有的項目開發中都會用到。可能你還不知道簡單工廠模式是什麼，但也許這種設計思想你早就在實際項目開發中接觸過了。

接下來就來看看簡單工廠模式到底是什麼。

首先大家想一個問題，如果叫你實現一個計算器控制檯程序，要求輸入兩個數和運算符號，得到運算結果，你會怎麼做？

初級版本：

class Program  
{  
    static void Main(string[] args)  
    {  
        try  
        {  
            Console.Write("請輸入數字A：");  
            string strNumberA = Console.ReadLine();  
            Console.Write("請選擇運算符號(+、-、*、/)：");  
            string strOperate = Console.ReadLine();  
            Console.Write("請輸入數字B：");  
            string strNumberB = Console.ReadLine();  
            string strResult = "";  
  
            switch (strOperate)  
            {  
                case "+":  
                    strResult = Convert.ToString(Convert.ToDouble(strNumberA) + Convert.ToDouble(strNumberB));  
                    break;  
                case "-":  
                    strResult = Convert.ToString(Convert.ToDouble(strNumberA) - Convert.ToDouble(strNumberB));  
                    break;  
                case "*":  
                    strResult = Convert.ToString(Convert.ToDouble(strNumberA) * Convert.ToDouble(strNumberB));  
                    break;  
                case "/":  
                    if (strNumberB != "0")  
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) / Convert.ToDouble(strNumberB));  
                    else  
                        strResult = "除數不能爲0";  
                    break;  
            }  
  
            Console.WriteLine("結果是：" + strResult);  
              
            Console.ReadLine();  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("您的輸入有錯：" + ex.Message);  
        }  
    }  
}

能寫出以上代碼已經不錯了，至少已經實現了目前的計算器功能。但是這個代碼是面向過程而非面向對象的，只能滿足當前的需求，程序不容易擴展和複用和維護。

試想，假如我現在又讓你寫一個Windows的計算器，你在原來的代碼上能改嗎？顯然，你還需要再重新寫一個程序。但是Windows計算器和控制檯計算器只是在顯示上不同，業務的邏輯處理是相同的。所以說你之前面向過程的程序是有弊端的：很難進行二次開發！

所以，接下來的改進之處就是利用面向對象的封裝特性，將業務邏輯與界面邏輯分開，使其耦合度下降，達到複用的目的;

升級版本：

界面邏輯部分：

class Program  
    {  
        static void Main(string[] args)  
        {  
            try  
            {  
                Console.Write("請輸入數字A：");  
                string strNumberA = Console.ReadLine();  
                Console.Write("請選擇運算符號(+、-、*、/)：");  
                string strOperate = Console.ReadLine();  
                Console.Write("請輸入數字B：");  
                string strNumberB = Console.ReadLine();  
                string strResult = "";  
                strResult = Convert.ToString(Operation.GetResult(Convert.ToDouble(strNumberA),Convert.ToDouble(strNumberB),strOperate));  
                Console.WriteLine("結果是：" + strResult);  
                Console.ReadLine();  
            }  
            catch (Exception ex)  
            {  
                Console.WriteLine("您的輸入有錯：" + ex.Message);  
            }  
        }  
    }

業務邏輯部分：

 public class Operation  
    {  
        public static double GetResult(double numberA,double numberB,string operate)  
        {  
            double result = 0d;  
            switch (operate)  
            {  
                case "+":  
                    result = numberA + numberB;  
                    break;  
                case "-":  
                    result = numberA - numberB;  
                    break;  
                case "*":  
                    result = numberA * numberB;  
                    break;  
                case "/":  
                    result = numberA / numberB;  
                    break;  
            }  
            return result;  
        }  
    }

以上版本代碼，把業務和界面分離，如果此時再讓寫一個Windows應用程序的計算器，就可以複用Operation運算類了，而且不單是Windows版，Web版、手機版、Pad版都可以複用。

接下來，假如我現在希望再增加一個開根(sqrt)運算，要怎麼改？你可能會想，直接在Operation裏添加一個分支運算就好了。但實際項目開發中，業務邏輯通常都會很複雜，要做很多的事，不只是做個加減法這麼簡單。所以，我們應該保證修改某一種類型業務而不會影響其他的。比如在這裏，我們應該將加減乘除等運算分離，修改其中一個而不影響另外幾個，增加運算代碼也不影響其他代碼，這體現了面向對象的繼承和多態特性。

高級版本：

   /// <summary>  
   /// 運算類  
   /// </summary>  
   class Operation  
   {  
       private double _numberA = 0;  
       private double _numberB = 0;  
         
       /// <summary>  
       /// 數字A  
       /// </summary>  
       public double NumberA  
       {  
           get{ return _numberA; }  
           set{ _numberA = value;}  
       }  
  
       /// <summary>  
       /// 數字B  
       /// </summary>  
       public double NumberB  
       {  
           get{ return _numberB; }  
           set{ _numberB = value; }  
       }  
  
       /// <summary>  
       /// 得到運算結果  
       /// </summary>  
       /// <returns></returns>  
       public virtual double GetResult()  
       {  
           double result = 0;   
           return result;  
       }       
   }

</pre><pre name="code" class="csharp">    ///summary
    /// 加法類  
    /// </summary>  
    class OperationAdd : Operation  
    {  
        public override double GetResult()  
        {  
            double result = 0;   
            result = NumberA + NumberB;  
            return result;  
        }  
    }

    /// <summary>  
    /// 減法類  
    /// </summary>  
    class OperationSub : Operation  
    {  
       public override double GetResult()  
        {  
            double result = 0;  
            result = NumberA - NumberB;  
            return result;  
        }  
    }

    /// <summary>  
    /// 乘法類  
    /// </summary>  
    class OperationMul : Operation  
    {  
        public override double GetResult()  
        {  
            double result = 0;  
            result = NumberA * NumberB;  
            return result;  
        }  
    }

    /// <summary>  
    /// 乘法類  
    /// </summary>  
    class OperationMul : Operation  
    {  
        public override double GetResult()  
        {  
            double result = 0;  
            result = NumberA * NumberB;  
            return result;  
        }  
    }

以上，首先是一個運算類，它有兩個Number屬性和一個虛方法GetResult(),加減乘除都是運算類的子類，繼承了它並重寫了GetResult()方法，這樣，修改某一個運算就不會影響其他的運算了。

那麼，如何讓計算器知道我們需要用哪一個方法呢？現在的問題其實就是如何去實例化對象，我們用一個單獨的類來做這個創造實例的過程，這就是工廠類，

 /// <summary>  
 /// 運算類工廠  
 /// </summary>  
 class OperationFactory  
 {  
     public static Operation createOperate(string operate)  
     {  
         Operation oper = null;  
         switch (operate)  
         {  
             case "+":  
                 {  
                     oper = new OperationAdd();  
                     break;  
                 }  
             case "-":  
                 {  
                     oper = new OperationSub();  
                     break;  
                 }  
             case "*":  
                 {  
                     oper = new OperationMul();  
                     break;  
                 }  
             case "/":  
                 {  
                     oper = new OperationDiv();  
                     break;  
                 }  
          }  
         return oper;  
     }  
 }

這樣，只要輸入運算符號，工廠就實例化出合適的對象，通過多態，返回父類的方法實現了計算器結果，這種方法就是簡單工廠模式。

Operation oper;  
oper = OperationFactory.createOperate("+");  
oper.NumberA = 1;  
oper.NumberB = 2;  
double result = oper.GetResult();

簡單工廠模式包含以下角色和職責：

工廠（Creator）：簡單工廠模式的核心，它負責實現創建所有實例的內部邏輯。工廠類的創建產品類的方法可以被外界直接調用，創建所需的產品對象。

抽象產品（Product）：簡單工廠模式所創建的所有對象的父類，它負責描述所有實例所共有的公共接口。

具體產品（Concrete Product）：是簡單工廠模式的創建目標，所有創建的對象都是充當這個角色的某個具體類的實例。

最後我們再總結一下簡單工廠模式的特性：

1.產品業務邏輯與界面邏輯分開；

2.將產品細分，不同種類的產品子類都有一個共同的抽象父類，重寫了父類的方法，各種產品互不干涉，修改某一個不會影響其他，並實現可可擴展;

3.增加一個工廠類Factory，該類負責根據條件選擇實例化哪一種產品，並創造實例；

4.如果需要增加運算，一方面需要增加產品子類，另一方面需要修改工廠類。

好了，以上便是簡單工廠模式的相關內容。

RapdoZoro

發佈了39 篇原創文章 · 獲贊 39 · 訪問量 15萬+

私信關注

設計模式--簡單工廠模式

DAPPER 事務 TRANSACTION

COCOS學習筆記--Cocod2dx內存管理(三)-Coco2d-x內存運行原理

COCOS學習筆記--內存管理(一)-引用計數和Ref類的講解

UE4學習筆記--AI感知系統AIPerception

UE4學習筆記--AI行爲樹架構

COCOS學習筆記--滑動條Slider及其控件屬性

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結