簡單工廠模式

工廠模式分為三種：簡單工廠模式、工廠方法模式、抽象工廠模式，此篇我們來總結簡單工程模式！

簡潔來說：簡單工廠模式用來解決執行個體化的問題。例如：存在加法，減法、乘法、除法的類時，當要利用加法時，就需要工廠來對加法類進行執行個體化，并傳回此執行個體，當要使用乘法，也需要工廠來對乘法類進行執行個體化，并傳回執行個體。即：對于有選擇性的去執行個體化類的操作都在一個【工廠類】中執行。

下面就看一個工廠類

public class OperateFactory
    {
        public static Operate GetInstace(string strOperate)
        {
            Operate oper = null;
            switch (strOperate)
            { 
                case "加法":
                    oper=new  OperateAdd();
                    break;
                case "減法":
                    oper=new OperateSubtraction();
                    break;
                default:
                   oper= null;
                    break;
            }
            return oper;
        }
    }

　　工廠類中進行邏輯判斷，最終得到要執行個體化的對象！

下面就用一個計算的執行個體來介紹：

　　//定義一個父類，來統一計算操作。
　　public class Operate
    {
        private int _numberA;
        private int _numberB;

        public int numberA
        {
            set { _numberA = value; }
            get { return _numberA; }
        }
        public int numberB
        {
            set { _numberB = value; }
            get { return _numberB; }
        }
　　　　 //其實可以将此類設定為抽象類，此方法設定為抽象方法，因為具體的實作都是在其派生類中進行的！
        public virtual int ObtainResult()
        {return 0;
        }
    }
　　//加法類
    public class OperateAdd:Operate
    {
        public override int ObtainResult()
        {
            return base.numberA + base.numberB;
        }
    }
　　//減法類
    public class OperateSubtraction : Operate
    {
        public override int ObtainResult()
        {
            return base.numberA - base.numberB;
        }
    }
　　上述代碼中，Operate類統一了計算操作，其派生類OperateAdd和OperateSubtraction實作了具體的加法、減法操作。
　　以上這段代碼，用到了面向對象三大特性之一：繼承。将所有派生類能用到的字段寫在父類中，以減少之後派生類中代碼的重寫(numberA和numberB字段)，派生類中重寫了父類的虛方法ObtainResult，來實作具體的操作。其實就上述代碼已經實作了面向對象的三大特性的全部，繼承是顯而易見，多态表現為父類Operate有多個派生類也就包含了多種狀态，封裝表現為每個派生類都對一種操作進行了封裝（加法，減法）

　　其實以上的代碼，就是面向對象的程式設計思想，如果現在想要做一個加法運算，我們可以new OperateAdd();減法運算則new OperateSubtraction();然後調用該執行個體的ObtainResult方法即可得到運算後的值。這樣操作的弊端是：我們需要進行邏輯判斷然後再顯示的去指定到底該去執行個體化那一個操作類，必然會增加執行代碼的條數和複雜程度。而簡單工廠模式就是用來解決這個問題的，簡單工廠模式的作用就是将邏輯判斷和再顯示的去指定該執行個體化的類封裝在工廠類中。如下面的代碼所示，在工廠類中增加一個靜态的并傳回值為Operate類型-具體操作類的父類，然後根據參數去來執行判斷，最終決定到底對那個類進行執行個體化。

public class OperateFactory
    {
        public static Operate GetInstace(string strOperate)
        {
            Operate oper = null;
            switch (strOperate)
            { 
                case "加法":
                    oper=new  OperateAdd();
                    break;
                case "減法":
                    oper=new OperateSubtraction();
                    break;
                default:
                   oper= null;
                    break;
            }
            return oper;
        }
    }

　　如此一來，隻需要傳遞一個參數給工廠類的靜态方法，它内部根據傳來的參數進行邏輯判定，最終得到對應的執行個體。

public int fun()
        {
            Operate op = OperateFactory.GetInstace("加法");
            op.numberA = 10;
            op.numberB = 5;
            return op.ObtainResult();
        }

如果要對現有的功能進行擴充，即：添加除法、指數、開根号等操作時，隻需要建立相應的操作類(繼承Operate類)，然後再在工廠類中添加相應的判斷邏輯即可！

作者：武沛齊

出處：http://www.cnblogs.com/wupeiqi/

本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接配接。