设计模式-简单工厂模式

在编程的过程中，尽可能的把代码的业务逻辑与界面分开，并且精心维护好自己的代码，经常去优化更新，这样可以提高以后的工作效率，在下次在写类似的功能的时候就可以将代码拿过来复用。

        面向对象的三大特效是封装，继承，多态，通过这3大特性可以把程序的耦合度降低，今天我要分享的设计模式叫”简单工厂模式“，用设计模式的好处是可以让程序变化的更加容易修改，更加容易复用。

        以计算器的程序为例子：

        封装业务类，将业务逻辑与界面分开，降低耦合度。

       首先封装一个运算类，定义一个GetResult的虚方法。

/// <summary>
    ///运算类
    /// </summary>
    public class Operation
    {
        public double NumberA { get; set; }

        public double NumberB { get; set; }

        /// <summary>
        /// 定义一个虚方法
        /// virtual 关键字用于在基类中修饰方法。virtual的使用会有两种情况：
        　　   ///情况1：在基类中定义了virtual方法，但在派生类中没有重写该虚方法。那么在对派生类实例的调用中，该虚方法使用的是基类定义的方法。
        　　   ///情况2：在基类中定义了virtual方法，然后在派生类中使用override重写该方法。那么在对派生类实例的调用中，该虚方法使用的是派生重写的方法。
        /// </summary>
        /// <returns></returns>
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

然后定义各种运算的子类，继承Operation类，并重写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>
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    /// <summary>
    /// 除法算法类
    /// </summary>
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB==0)
            {
                throw new Exception("除数不能为0");
            }
            result = NumberA / NumberB;
            return result;
        }
    }

然后在定义一个简单工厂类

/// <summary>
    /// 简单工厂类
    /// 描述：简单工厂模式
    /// </summary>
    public class OperationFactory
    {
        public static Operation CreaterOperate(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;
        }
    }

 然后客户端代码如下，这样就完全把业务类与界面分离开了。现在这个计算器的程序就可以复用了，不管是Windows程序，Web版程序，或者是手机等需要用到计算器的软件都可以复用这样的代码。

static void Main(string[] args)
        {
            Console.WriteLine("请输入一个数");
            double NumberA = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入运算符");
            string strOperate = Console.ReadLine();
            Console.WriteLine("请输入第二个数");
            double NumberB = Convert.ToDouble(Console.ReadLine());
            Operation oper;
            oper = OperationFactory.CreaterOperate(strOperate);
            oper.NumberA = NumberA;
            oper.NumberB = NumberB;
            double result = oper.GetResult();
            Console.WriteLine("结果{0}",result);
            Console.ReadKey();        
        }

本人原创地址：http://www.goodtools123.com/contents/2/49.html

标签：oper,NumberB,double,模式,工厂,result,Operation,设计模式,public
来源： https://blog.51cto.com/u_15051447/2871912