简单的工厂模式

说到工厂模式，我们在此处先来做一道编程题吧！

假设面试的时候，面试官要你做一道笔试题：给定两个数字A和B，然后敲定运算符，根据给定的运算符来得到所需的结果！

我相信，很多的面试者最先写出来的代码都是这个样子的：

static void Main(string[] args)
{
    while (true)
    {
        Console.Write("请输入数字A：");
        string strNumA = Console.ReadLine();
        Console.Write("请输入数字B：");
        string strNumB = Console.ReadLine();
        Console.Write("请选择操作运算符（+、-、*、/）:");
        string strOperarte = Console.ReadLine();
        string Result = "";
        switch (strOperarte)
        {
            case "+":
                Result = Convert.ToString(Convert.ToDouble(strNumA) + Convert.ToDouble(strNumB));
                break;
            case "-":
                Result = Convert.ToString(Convert.ToDouble(strNumA) - Convert.ToDouble(strNumB));
                break;
            case "*":
                Result = Convert.ToString(Convert.ToDouble(strNumA) * Convert.ToDouble(strNumB));
                break;
            case "/":
                if (strNumB == "0")
                    Result = "警告：除数不能为 0";
                else
                    Result = Convert.ToString(Convert.ToDouble(strNumA) / Convert.ToDouble(strNumB));
                break;
            default:
                Result = "你当前的输入有误";
                break;
        }
        Console.WriteLine(Result);
    }
    Console.ReadKey();
}

上面的这段代码，虽然看上去可行，但是在企业中的进行代码编写的时候，一般是讲究代码的复用的。假设我们需要添加一个求平方根的运算的话，那你要怎么更改呢？

所以在这里我们就需要用到，这里我们说到的工厂模式了。

简单工厂模式：又叫做是静态的工厂方法模式，由一个工厂的对象 创造出创建哪一类的实例化对象，实现对应的过程。

看到上面的定义之后，我们可以明确的看出来，在此处我们需要用到的是虚函数实现多态的实例化操作。主要的实现代码如下：

先实现几个基类，定义基本的运算：

public  class Operation
{
    private double _numA = 0;
    private double _numB = 0;
    public double NumA
        {
            set { _numA = value; }
            get { return _numA; }
        }
    public double NumB
        {
            set { _numB = value; }
            get { return _numB; }
        }
    //定义一个虚函数 
    public virtual double GetResult()
        {
            return 0;
        }
}

接着，继续定义几个需要实现运算的子类：

public class OperationAdd : Operation
    {
        public override double GetResult()
        {
            return NumA + NumB;
        }
    }
public class OperationSub : Operation
    {
        public override double GetResult()
        {
            return NumA - NumB;
        }
    }
public class OperationMul : Operation
    {
        public override double GetResult()
        {
            return NumA * NumB;
        }
    }
public class OperationDiv : Operation
    {
        public override double GetResult()
        {
            if (NumB == 0)
                throw new Exception("除数不能为0");
            return NumA / NumB;
        }
    }

当我们需要添加运算符的时候，只需要添加的是一个子类实现运算就好了。

下面是实现一个工厂类，可以实现多对象的调用：

class OperationFactory
{
    public static Operation CreateOperator(string strOper)
        {
            Operation Oper = null;
            switch (strOper)
            {
                case "+":
                    Oper = new OperationAdd();
                    break;
                case "-":
                    Oper = new OperationSub();
                    break;
                case "*":
                    Oper = new OperationMul();
                    break;
                case "/":
                    Oper = new OperationDiv();
                    break;
            }
            return Oper;
        }
}

上面的代码，主要是运用到面向对象的多态，来实现自己的函数实现 。

这样一个简单的工厂类就实现了。