大话设计模式--简单工厂模式

先摘录一段作者的原文：

设计模式的四种境界：

1.没学之前是有点不懂，根本想不到用设计模式，设计的代码很糟糕。

2.学了几个模式之后，很开心，于是到处想要用自己学过的模式，于是常造成误用各种模式而不自知。

3.学完全部模式，感觉诸多模式极其相似，无法分清模式之间的差异，有困惑，但深知误用之害，应用之时有所犹豫。

4.灵活应用各种模式，甚至不用具体的某模式也能设计出优秀的代码。

 

是什么？

简单工厂模式是通过传入的数据返回几种可能类中的一种类的实例。但这几种类一般会有一个共同特点是，这几种类都有一个共同的父类和共同的方法，但每个方法执行的内容不同，而且根据不同的数据进行优化。

 

 

形象化例子：

当我们在买早餐的时候，早餐店里都卖得写什么呢？这点你有注意吗？众多食品摆在那里，你只对营业员说你要何种食品，他便会知道给你拿什么样的食品给你，这说明什么呢？如果用面向对象的思想来理解的话，营业员在这里就充当了一个工厂的角色，他负责根据你的请求返回你需要的食品对象。而这一点正是简单工厂模式的意图。

 

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.Write(result+"\n");
        }
    }
    public class Operation
    {
        private Double _numberA = 0;
        private Double _numberB = 0;
        public double NumberA
        {
            get
            {
                return _numberA;
            }
            set
            {
                _numberA = value;
            }
        }
        public double NumberB
        {
            get
            {
                return _numberB;
            }
            set
            {
                _numberB = value;
            }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
            {
                throw new Exception("除数不能为0");
            }
            result = NumberA / NumberB;
            return result;
        }
    }
    public 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;
        }
    }
}

修改加法运算只需要修改OperationAdd就可以了，而如果我们需要增加各种复杂运算，譬如平方根啊，立方根啊自然对数啊等我们只需要增加相应的运算子类以及在switch中增加分支就行了,如果需要修改界面就只需修改界面的代码和运算的类没有关系了。

这里就是用到了多态，即子类以父类的身份出现，却以自己的方式去实现。 
这里就是加减乘除类以运算父类的身份出现，但每个子类实现GetResult()的方法是各自不同的，这样实现了界面代码根本不用去创建具体实例，达到松耦合的目的。