设计模式之-简单工厂模式

工厂模式，顾名思义，用来生产的；那么在程序中，就是用来“生产对象”的

做一个简单的计算器控制台，有基本的“加减乘除”功能。

抽象出：Operation.cs //计算类

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

        public virtual double GetResult() //虚方法 ,子类中override重新覆盖该方法
        {
            double result = 0;
            return result;
        }
    }

具体实现类：OperationAdd.cs 继承类：Operation.cs  重写抽象方法GetResult(), 实现具体的GetResult()计算方法

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

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

    /// <summary>
    /// 乘法
    /// </summary>
    public class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

    /// <summary>
    /// 除法
    /// </summary>
    public class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA / NumberB;
            return result;
        }
    }

如果，按照思维来说，我们会直接使用  具体的运算方法：如 

            OperationAdd operationAdd=new OperationAdd();
            operationAdd.NumberA = 20;
            operationAdd.NumberB = 10;
            operationAdd.GetResult();            

使用简单工厂模式的方式如下：

OperationFactory.cs //算法工厂类

     /// <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;
                    }
                case "*":
                    {
                        operation = new OperationMul();
                        break;
                    }
                case "/":
                    {
                        operation = new OperationDiv();
                        break;
                    }
            }
            return operation;
        }
    }

算法工厂的好处就是，更具需求创建相对应的算法

主函数如下：

    class Program
    {
        static void Main(string[] args)
        {
            //一般调用
            OperationAdd operationAdd = new OperationAdd();
            operationAdd.NumberA = 20;
            operationAdd.NumberB = 10;
            operationAdd.GetResult();

            //工厂模式调用
         Operation add = OperationFactory.CreateOperate("+");
            add.NumberA = 1;
            add.NumberB = 2;
            var result = add.GetResult();
            Console.WriteLine(result);
            Console.ReadLine();

            Operation sub = OperationFactory.CreateOperate("-");
            sub.NumberA = 20;
            sub.NumberB = 10;
            var resultA = sub.GetResult();
            Console.WriteLine(resultA);
            Console.ReadLine();
        }
    }

 

总结：从代码上来看

 //一般调用
    OperationAdd operationAdd = new OperationAdd();

//工厂模式调用
    Operation add = OperationFactory.CreateOperate("+");

1，一般调用：直接调用了具体的运算对象（new OperationAdd();） ，暴露了方法，也提高了耦合性。客户端直接和具体逻辑算法连接。不易后期维护

2，相对来说，工厂模式的优势体现出来了 ，如果要要修改的话。修改具体逻辑就行。如果添加了具体算法，只有在工厂类OperaFactory添加分支就行了

 

 

 

-----------------------------

非常感谢《大话设计模式》一书，看了好几遍，建议小白动手写写，会有感触的。本代码也是大化设计模式的案例中动手写的。

--欢迎吐槽，我也是菜鸟，一路逛奔的菜鸟

 再次感谢《大话设计模式》作者:程杰