簡單工廠設計模式[]_ZenDei技術網路在線

本寶寶只是一個菜鳥，寫寫學習筆記，以便溫故知新，如果哪裡不對或者不足，望大牛指正。 1.我們先舉個例子說明一下，eg:加減乘除的運算[一步步優化] ⅰ.[第一種寫法] ⅱ.以上的這種寫法，顯得特別不專業，也不美觀，那就優化一下，看看[第二種寫法] ⅲ.以上寫法是不是也有許多不足呢？業務邏輯層和和客 ...

本寶寶只是一個菜鳥，寫寫學習筆記，以便溫故知新，如果哪裡不對或者不足，望大牛指正。

1.我們先舉個例子說明一下，eg:加減乘除的運算[一步步優化]

ⅰ.[第一種寫法]

 class Program
    {
        static void Main(string[] args)
        {
            //第一種方法，顯得不專業
            //輸入
            Console.Write("請輸入一個數字:");
            //接收
            string A = Console.ReadLine();
            Console.Write("請輸入運算符，+、-、*、/");
            string B = Console.ReadLine();
            Console.Write("請輸入第二個數字");
            string C = Console.ReadLine();
            Console.Write("結果等於");
            string D = "";
            if (B == "+")
            {
                //string轉換為double,不能忘記tostring()
                D = (Convert.ToDouble(A)+Convert.ToDouble(C)).ToString();
            }
            if (B == "-")
            {
                D = (Convert.ToDouble(A) + Convert.ToDouble(C)).ToString();
            }
            if (B == "*")
            {
                D=(Convert.ToDouble(A)+Convert.ToDouble(C).ToString());
            }
            if (B == "/")
            {
                D=(Convert.ToDouble(A)+Convert.ToDouble(C).ToString());
            }
            Console.WriteLine("結果是："+D);
        }
    }

ⅱ.以上的這種寫法，顯得特別不專業，也不美觀，那就優化一下，看看[第二種寫法]

class Program
    {
        static void Main(string[] args)
        {
            //這是第二種方式
            try
            {
                Console.WriteLine("請輸入一個數字");
                string sInum1 = Console.ReadLine();
                Console.WriteLine("請輸入運算符,+、-、*、/");
                string Oper = Console.ReadLine();
                Console.WriteLine("請輸入第二個數字");
                string sInum2 = Console.ReadLine();
                string sResult = "";
                switch (Oper)
                {
                    case "+":
                        sResult = (Convert.ToDouble(sInum1) + Convert.ToDouble(sInum2)).ToString();
                        break;
                    case "-":
                        sResult = (Convert.ToDouble(sInum1) + Convert.ToDouble(sInum2)).ToString();
                        break;
                    case "*":
                        sResult = (Convert.ToDouble(sInum1) + Convert.ToDouble(sInum2)).ToString();
                        break;
                    case "/":
                        if (sInum2 == "")
                        {
                            sResult = "被除數不能為0";
                        }
                        else
                        {
                            sResult = (Convert.ToDouble(sInum1) + Convert.ToDouble(sInum2).ToString());
                        }
                        break;
                }
                Console.WriteLine("結果為：" + sResult);
            }
            catch (Exception ex)
            {
               // Console.WriteLine(ex);
                Console.WriteLine("溫馨提示，網站正在維修，請聯繫管理員");
            }   
        }
    }

ⅲ.以上寫法是不是也有許多不足呢？

業務邏輯層和和客戶端混合在一起，高耦合，關聯性太強：1.不利於使用和擴展;2.不安全;

那就再優化一下，看看[第三種寫法][創建一個operating類之後調用]

我們把業務邏輯層和客戶端分開，就好比我們買個車子，只需知道它如何使用就好。

class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("請輸入第一個數:");
                string sInum1 = Console.ReadLine();
                Console.WriteLine("請輸入運算符,+、-、*、/");
                string sOper = Console.ReadLine();
                Console.WriteLine("請輸入第二個數:");
                string sInum2 = Console.ReadLine();
                string sResult = "";
                sResult = (Operating.GetResult(Convert.ToDouble(sInum1),Convert.ToDouble(sInum2),sOper)).ToString();
                Console.WriteLine("結果為:"+sResult);
            }
            catch (Exception ex)
            {
                Console.WriteLine("溫馨提示，網站正在維修，請聯繫管理員");
            }
        }
    }

我們把業務邏輯層和客戶端分開，以下代碼相當於車子最核心，最底層的東西。

class Operating
    {
        public static double GetResult(double iNum1, double iNum2, string sOper)
        {
            double Result = 0d;
            switch (sOper)
            {
                case "+":
                    Result = iNum1 + iNum2;
                    break;
                case"-":
                    Result = iNum1 - iNum2;
                    break;
                case"*":
                    Result = iNum1 * iNum2;
                    break;
                case"/":
                    Result = iNum1 / iNum2;
                    break;
            }
            return Result;}
    }

ⅳ.以上寫法有什麼不足呢？

還是高耦合，如果在加一個開平方根，整個程式又要重新運行;

假如現在是在做銀行系統或安全繫數高的，如果+,-,*,/都是各部分許可權不同的人開發的，這樣寫它們都會互相看到；

[那我們就試試第四種方式，簡單工廠的設計模式]

把Operating作為一個父類，寫一些公共的東西，只是定義一個方法名，不作具體的實現操作。

class Operating
    {
        public double dNum1{get;set;}
        public double dNum2{get;set;}
        public virtual double GetResult()
        {
            double Result = 0;
            return Result;
        }
    }

定義一個虛方法，子類只需覆寫[+的操作]

class OperAdd:Operating
    {
        //子類覆寫
        public override double GetResult()
        {
            double Result=0;
            Result = dNum1 + dNum2;
            return Result;
        }
    }

class OperReduce:Operating
    {
        public override double GetResult()
        {
            double Result = 0;
            Result = dNum1 - dNum2;
            return Result;
        }
    }

class OperRide:Operating
    {
        public override double GetResult()
        {
            double Result = 0;
            Result = dNum1 * dNum2;
            return Result;
        }
    }

class OperExcept:Operating
    {
        public override double GetResult()
        {
            double Result = 0;
            if (dNum2 == 0)
            {
                Console.WriteLine("被除數不能為0");
            }
            else
            {
                Result = dNum1 / dNum2;
            }
            return Result;
        }
    }

定義一個工廠類OperateFactory.cs

class OperateFactory
    {
        //創建一個OperateFactory類，用於接收客戶端傳過來的是"+、-、*、/"
        public static Operating CreateOper(string sOper)
        {
            Operating oper = null;
            switch (sOper)
            {
                case"+":
                    oper = new OperAdd(); //如果是+,我們就創建一個+的對象,調用GetResult()，做處理
                    break;
                case"-":
                    oper = new OperReduce(); //如果是-,我們就創建一個-的對象
                    break;
                case"*":
                    oper = new OperRide();
                    break;
                case"/":
                    oper = new OperExcept();
                    break;
            }
            return oper;
        }
    }

再看一下客戶在調用的時候的代碼：

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("請輸入第一個數:");
            string sNum1 = Console.ReadLine();
            Console.WriteLine("請輸入運算符,+、-、*、/");
            string sOper = Console.ReadLine();
            Console.WriteLine("請輸入第二個數:");
            string sNum2 = Console.ReadLine();
            string sResult="";
            Operating oper;
            oper = OperateFactory.CreateOper(sOper);
            oper.dNum1 = Convert.ToDouble(sNum1);
            oper.dNum2 = Convert.ToDouble(sNum2);
            sResult = oper.GetResult().ToString();
            Console.WriteLine("結果等於:"+sResult);
        }
    }

開髮結果：

2.實例說明：

簡單工廠設計模式：在面向對象程式設計中，對程式開發人員而言，最常見的設計模式就是簡單工廠模式。簡單工廠模式根據提供給它的數據，返回幾個類中的一個類的實例。通常返回的類都有一個公共父類和公共方法，但是每個方法實現的功能不同，並且根據不同的數據進行初始化。

優點：工廠類含有必要的判斷邏輯，可以決定在什麼時候創建哪一個產品類的實例，客戶端可以免除直接創建產品對象的責任，而僅僅“消費”產品。簡單工廠模式通過這種做法實現了對責任的分割。

低耦合，代碼復用性高，擴展性強；

缺點：當產品有複雜的多層等級結構時，工廠類只有自己，以不變應萬變，就是模式的缺點。因為工廠類集中了所有產品創建邏輯，一旦不能正常工作，整個系統都要受到影響。同時，系統擴展困難，一旦添加新產品就不得不修改工廠邏輯，有可能造成工廠邏輯過於複雜。

3.簡單工廠角色與結構圖：

就暫時更新到這裡吧，睡覺吧，畢竟身體棒棒才能繼續學習。