简单工厂模式（2）

一、举例

用控制台程序做一个非常简单的计算机，实现加减乘除运算即可，那么，大家自然而然的会写出如下代码

static void Main(string[] args)
        {
            Console.WriteLine("请输入数字A:");
            string strNumA = Console.ReadLine();
            Console.WriteLine("请选择运算符号(+、-、*、、)");
            string strOperate = Console.ReadLine();
            Console.WriteLine("请输入数字C:");
            string strNumB = Console.ReadLine();
            string strResult = "";
            if (strOperate == "+")
            {
                strResult = Convert.ToString(Convert.ToDouble(strNumA) + Convert.ToDouble(strNumB));
            }
            if (strOperate == "-")
            {
                strResult = Convert.ToString(Convert.ToDouble(strNumA) - Convert.ToDouble(strNumB));
            }
            if (strOperate == "*")
            {
                strResult = Convert.ToString(Convert.ToDouble(strNumA) * Convert.ToDouble(strNumB));
            }
            if (strOperate == "/")
            {
                strResult = Convert.ToString(Convert.ToDouble(strNumA) / Convert.ToDouble(strNumB));
            }
            Console.WriteLine($"结果是：{strResult}");
            Console.ReadKey();
        }

二、演绎

1、第一步演绎

①由于在判断运算符时，用的是if语句，这意味着每个条件都需要做判断，相当于计算机做了三次无用功。

②没有输入校验，例如，除数不能为零的问题等等

就上述两个问题，做如下修改：（输入校验此处先只做除数为零的校验）

static void Main(string[] args)
        {
            Console.WriteLine("请输入数字A:");
            string strNumA = Console.ReadLine();
            Console.WriteLine("请选择运算符号(+、-、*、、)");
            string strOperate = Console.ReadLine();
            Console.WriteLine("请输入数字C:");
            string strNumB = Console.ReadLine();
            string strResult = "";
            switch (strOperate)
            {
                case "+":
                    strResult = Convert.ToString(Convert.ToDouble(strNumA) + Convert.ToDouble(strNumB));
                    break;
                case "-":
                    strResult = Convert.ToString(Convert.ToDouble(strNumA) - Convert.ToDouble(strNumB));
                    break;
                case "*":
                    strResult = Convert.ToString(Convert.ToDouble(strNumA) * Convert.ToDouble(strNumB));
                    break;
                case "/":
                    if (strNumB != "0")
                    {
                        strResult = Convert.ToString(Convert.ToDouble(strNumA) / Convert.ToDouble(strNumB));
                    }
                    else
                    {
                        strResult = "除数不能为0";
                    }
                    break;
            }
            Console.WriteLine($"结果是：{strResult}");
            Console.ReadKey();
        }

2、第二步演绎

①上述写的简单的计算器仅仅体现了面向过程的编程，没有体现面向对象的编程

②上述代码使用控制台应用实现的，假如有一天我需要用Winform、Web 等实现一模一样的需求，那么，上述代码则需要重新编写，好可怕。

就上述问题，做如下修改：

将业务逻辑与界面分离

Operation运算类

public class Operation
    {
        public static double GetResult(double numA, double numB, string strOperate)
        {
            double result = 0d;
            switch (strOperate)
            {
                case "+":
                    result = numA + numB;
                    break;
                case "-":
                    result = numA - numB;
                    break;
                case "*":
                    result = numA * numB;
                    break;
                case "/":
                    result = numA / numB;
                    break;
            }
            return result;
        }
    }

客户端

static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("请输入数字A:");
                string strNumA = Console.ReadLine();
                Console.WriteLine("请选择运算符号(+、-、*、、)");
                string strOperate = Console.ReadLine();
                Console.WriteLine("请输入数字C:");
                string strNumB = Console.ReadLine();
                string strResult = "";
                strResult = Convert.ToString(Operation.GetResult(Convert.ToDouble(strNumA), Convert.ToDouble(strNumB), strOperate));
                Console.WriteLine($"结果是：{strResult}");
                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"您的输入有错：{ex.Message}");
            }
        }

这样的话，无论是控制台，还是Winform以及其他应用，只需要调用 Operation 这个类即可了。实现了业务逻辑与界面的分离。这里，也用到了面向对象编程的三大特性之一的封装。

3、第三步演绎

①如果我想增加一种计算方式，例如开根号（sqrt）运算怎么办，只能是修改Operation类，在switch中增加一种情况。

②针对①问题做修改的话，那么另一个问题就来了，我修改Oeration类的时候，之前写好的加减乘除功能全在其中，如果我不小心，或者有意搞破坏，将本来运行的好好的加减乘除功能改掉，怎么办？（此例中仅仅是计算器，如果换做是成熟的产品，或者涉及到资金运算等等的代码，运行的好好的，不可能会让程序员在其中胡作非为的）

针对上述问题，作如下修改：

我可以将加减乘除各种运算分别封装到不同的类里面，这样，就能解决②的问题，每增加一种运算，我就增加一个类，这样①问题也解决了。

首先，将不同的运算抽象出一个共同的类，即父类

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;
        }
    }

其次，让不同的运算继承这个父类，然后根据不同的运算，重写父类中的GetResult方法

//加法类
    public class OperationAdd:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    //减法类
    public class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA = NumberB;
            return result;
        }
    }
    //乘法类
    public class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    //除法类
    public class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB==0)
            {
                throw new Exception("除数不能为0");
            }
            result = NumberA / NumberB;
            return result;
        }
    }

这样，上述的两个问题就迎刃而解了。

4、第四步演绎

到了简单工厂最核心的地方了。

 这么多的类，客户端该如何用这些类呢，换句话说，客户端如何实例化这些类呢？那么，就需要一个核心的东西——工厂，这个工厂负责给客户端提供他想要的类的实例。我想要实例化什么类，告诉工厂就可以了。

代码如下：

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;
        }
    }

注意一点，这个工厂中的方法，返回的是加减乘除这些类的父类。

好了，制造类实例的工厂有了，那么，客户端只需要告诉工厂，给我造一个什么类的实例，然后用这个实例就可以了。

客户端代码如下

static void Main(string[] args)
        {
            Operation oper;
            //告诉工厂，给我一个加法类的实例
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.WriteLine(result);
            Console.ReadKey();
        }

 经过上述一系列的演绎，也就形成了简单工厂模式。

三、总结

简单工厂模式，即 通过一个‘工厂类’，用于子类返回父类对象。

---

工厂模式结束，下一次，将讲解策略模式