工厂方法模式

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类

仔细观察会发现，工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单的工厂内部逻辑判断移到客户端代码来进行，你想要加载的功能，本来是该工厂类，而现在是修改客户端

下面是小案例

假设现在要进行计算器的运算，会首先存在一个运算类，包含数字A和数字B，还有一个虚方法返回结果

namespace Study.Factory
{
    /// <summary>
    /// 运算类
    /// </summary>
   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;
        }
    }
}

　然后定义具体的运算子类，具体实现运算方法（其他计算方法类似）

namespace Study.Factory
{
    /// <summary>
    /// 加法
    /// </summary>
    class OpeationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
}

定义工厂接口

namespace Study.Factory
{
    interface IFactory
    {
        Operation CreateOperation();
    }
}

　　

定义加法工厂实现接口，返回运算方法（同理，减法，乘法，除法依次类推）

namespace Study.Factory
{
    class FactoryAdd : IFactory
    {
        public Operation CreateOperation()
        {
            return new OpeationAdd();
        }
    }
}

　　

最后客户端调用

 /// <summary>
        /// 工厂方法模式
        /// </summary>
        static void Factory()
        {
            Console.WriteLine("请输入数字A");
            double _numberA = double.Parse(Console.ReadLine());
            Console.WriteLine("请输入数字B");
            double _numberB = double.Parse(Console.ReadLine());

            //创建加法工厂
            IFactory fa = new FactoryAdd();
            //实例化具体的算法
            Operation oper = fa.CreateOperation();
            oper.NumberA = _numberA;
            oper.NumberB = _numberB;
            Console.WriteLine(oper.GetResult());
        }
    }