设计模式之简单工厂模式

工厂模式（Factory Pattern）是面向对象开发中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

下面就以计算器的实现为例：

首先创建运算类

    /// <summary>
    /// 运算类
    /// </summary>
    public abstract class Operation
    {
        private double _numberA;
        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }

        private double _numberB; 
        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

        /// <summary>
        /// 运算方法的抽象方法
        /// </summary>
        /// <returns></returns>
        public abstract double GetResult();
    }

    /// <summary>
    /// 加法类
    /// </summary>
    class OperationAdd : Operation
    {
        
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    /// <summary>
    /// 减法类
    /// </summary>
    class OperationSub:Operation
    {
        
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

然后是工厂类

    /// <summary>
    /// 运算工厂类
    /// </summary>
    public class OperationFactory
    {
        /// <summary>
        /// 运算对象生成工厂（通过不同的运算符号实例化对应的对象（多态））
        /// </summary>
        /// <param name="operate">运算符号</param>
        /// <returns></returns>
        public static Operation CreateOperate(string operate)
        {
            Operation operation = null;
            switch (operate)
            {
                case "+":
                    operation = new OperationAdd();
                    break;
                case "-":
                    operation = new OperationSub();
                    break; 
            }
            return operation;
        }
    }

最后是客户端代码

        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("请输入数字A：");
                double numberA = Convert.ToDouble(Console.ReadLine());
                Console.WriteLine("请输入[+，-]中的一个运算符：");
                string oper = Console.ReadLine();
                Console.WriteLine("请输入数字B：");
                double numberB = Convert.ToDouble(Console.ReadLine());
                //声明一个运算类
                Operation operation;
                //利用工厂模式来实例化不同的运算对象（多态）
                operation = OperationFactory.CreateOperate(oper);
                operation.NumberA = numberA;
                operation.NumberB = numberB;
                //调用对象重写的GetResult()方法实现计算器的功能
                double result = operation.GetResult();
                Console.WriteLine("计算的结果为：{0}", result);
                Console.ReadLine();
            }
            catch (Exception)
            {
                Console.WriteLine("您输入的格式不正确！");
                Console.Read();
            }
        }

这样，我们通过输入不同的运算符号，工厂就能实例化出合适的对象，然后再通过多态，返回父类的方式实现计算器的结果。