设计模式之简单工厂

面向对象编程特点：可维护，可复用，可扩展，灵活性高。 通过封装，继承，多态把程序耦合度降低，用设计模式使得程序更加灵活，容易修改，易于复用。 

案例：实现计算器控制台程序：

第一次做法：直接MAIN函数里面洋洋洒洒写下来所有代码。

缺点：无复用性

第二次做法：考虑业务的复用性，封装一个运算类（方法）通过形参把要操作的数字和符号输入，得到结果。只要调去这个运算方法，计算器，PDA多种设备都可以实现计算功能

缺点：如果增加一个开平方运算，则需要修改这个核心方法，有可能被修改人增加别的后门程序，或者修改之前确定了的方法。

第三次做法：设定一个父类，里面设置要进行操作的两个数组作为属性，设置得到运算结果的虚方法GetResult()，再分别写出加减乘除的子类继承父类，每个子类实现自己的GetResult()方法。这样当增加开平方运算的时候，只需要新建立一个子类，继续继承父类，实现虚方法即可，不影响其他的方法。

public class Operator
    {
        public double NumberA { get; set; }
        public double NumberB { get; set; }
        public virtual double GetResult() 
        {
            double result = 0;
            return result;
        }
    }

    class OperatorAdd :Operator
    {
        public override double GetResult()
        {
            return NumberA + NumberB;
        }
    }

    class OperatorSub : Operator
    {
        public override double GetResult()
        {
            return NumberA - NumberB;
        }
    }

优点案例：比如有个公司薪资管理系统，分技术月薪，销售月薪，经理月薪。现在增加一个兼职人员月薪需要写入，完全不影响前三种情况，直接加一个子类继承父类即可。

缺点：如何让计算器知道要做的是加是减还是乘除？

最终做法：再建立一个工厂方法，在工厂方法里用多态根据符号判断该用哪个子类，直接实例化出合适对象，通过多态返回父类的方法实现结果。

 public class OperatorFactory
    {
        public static Operator CreateOperator(string sign)
        {
            Operator opter = null;
            switch(sign)
            {
                case "+" :
                    opter = new OperatorAdd();
                    break;
                case "-":
                    opter = new OperatorSub();
                    break;
            }
            return opter;
        }
    }

客户端代码只需要很简单的输入内容即可：

 static void Main(string[] args)
        {
            Operator oper;
            oper = OperatorFactory.CreateOperator("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            var temp = oper.GetResult();
            Console.Write(temp);
            Console.ReadLine();
        }

至此，如果加法方法变更，只需要修改加法的子类，如果需要增加开平方，则增加一个开平方类继承父类，同时在工厂里面加上相应的CASE对应。