简单工厂模式

本文借鉴《大话设计模式》，算是对自己学习的总结，也希望分享下所学知识~~

什么是简单工厂模式：就是一种实例化对象的方式。

下面使用一个计算器范例，来说明什么是简单工厂模式：
如果面试让你实现一个计算器，有的人可能会这么写。

class BadCalc
    {
        float numberA;
        float numberB;
        float result;

        EOperation operation = EOperation.Add;

        public void DoCalc()
        {
            switch (operation)
            {
                case EOperation.Add:
                    result = numberA + numberB;
                    break;

                case EOperation.Subtract:
                    result = numberA - numberB;
                    break;

                case EOperation.Multiply:
                    result = numberA * numberB;
                    break;

                case EOperation.Divide:
                    if (numberB == 0)
                    {
                        throw new DivideByZeroException();
                    }
                    else
                    {
                        result = numberA / numberB;
                    }
                    break;
            }
        }
    }

这里需要注意2点：
1.除法为0判断
2.命名规范
（如果写的比这个还差，那你需要反思了。。）

这样写有什么问题呢？
1.如果需要新增运算，每次运算都需要增加一个分支，还需要让加减乘除都得参与进编译的过程，如果不小心把加法改成了除法，就会造成不可挽回的严重问题了。
2.如果需要新增运算算法，就会看到其他算法的算法，如果这个算法涉及到核心问题（比如：薪资），就会有被修改的风险。

如何改进呢？

思路：需要运行继承和多态，把加减乘除等运算分离，修改一个不影响另外几个，增加算法也不会涉及到其他代码。

首先提取出一个运算基类：
包含两个运算的前后数，另外有一个虚方法，用于计算得到结果。

    class Operation
    {
        public float NumberA
        {
            get; set;
        }
        public float NumberB
        {
            get; set;
        }

        public virtual float GetResult()
        {
            float result = 0;
            return result;
        }
    }

其他的加减乘除都写成了运算类的子类，继承它（Operation）后，重写这个虚方法（GetResult）。

class AddOperation : Operation
    {
        public override float GetResult()
        {
            float result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class SubOperation : Operation
    {
        public override float GetResult()
        {
            float result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class MulOperation : Operation
    {
        public override float GetResult()
        {
            float result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class DivOperation : Operation
    {
        public override float GetResult()
        {
            float result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

这样如果修改任何一个算法，就不需要提供其他算法的代码了。
如果需要增加复杂运算，（比如：开根号），就去增加对应的运算子类就OK。

那么新问题来了，如何让程序知道我使用哪一种算法呢？（加减或者是乘除）
这时候就需要使用到一种设计模式：简单工厂设计模式。
使用一个单独的类来做这个创造实例的过程。因为到底要实例化谁，将来会不会新增加实例化对象，这都是很容易变化的地方，如果直接写到程序里new出来，会造成维护的困难，所以就需要使用到单独的一个类。

    class OperationFactory
    {
        public static Operation CreateOperation(EOperation operation)
        {
            Operation result = null;
            switch (operation)
            {
                case EOperation.Add:
                    result = new AddOperation();
                    break;
                case EOperation.Subtract:
                    result = new SubOperation();
                    break;
                case EOperation.Multiply:
                    result = new MulOperation();
                    break;
                case EOperation.Divide:
                    result = new DivOperation();
                    break;
            }
            return result;
        }
    }

这样在新增了运算算法之后，只需要在switch里面增加分支即可。

那么我们再来看一下如何使用？

    class GoodCalc
    {
        public void DoCalc()
        {
            Operation oper = OperationFactory.CreateOperation(EOperation.Add);
            oper.NumberA = 1;
            oper.NumberB = 2;
            float result = oper.GetResult();
        }
    }

这样看起来，程序写的就十分完美了。
只需输入运算符号，工厂就会实例化出合适的对象，通过多态，返回给父类的方式实现了计算器的结果。
以后无论是控制台程序、windows程序，还是手机程序，都可以用这段代码来实现计算器功能。

好啦，今天的简单工厂模式就介绍完了，谢谢大家~

最后编辑于：2019.10.14 16:49:47