简单工厂模式

 工厂模式分为三种：简单工厂模式、工厂方法模式、抽象工厂模式，此篇我们来总结简单工程模式！

 简洁来说：简单工厂模式用来解决实例化的问题。例如：存在加法，减法、乘法、除法的类时，当要利用加法时，就需要工厂来对加法类进行实例化，并返回此实例，当要使用乘法，也需要工厂来对乘法类进行实例化，并返回实例。即：对于有选择性的去实例化类的操作都在一个【工厂类】中执行。
下面就看一个工厂类

    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类)，然后再在工厂类中添加相应的判断逻辑即可！