计算器设计

做软件这个行业，我们必须知道，用户的需求是不断变化的，有时候，用户提的要求可能非常不过分，只是改动一些表面的小地方。但是面对已完成的代码，却是需要几乎重头来过的尴尬，实在痛苦不堪。

之所以会出现这种状况，就是因为我们原先所写的程序，不容易维护，灵活性差，不容易扩展，更谈不上复用了。

面向对象分析设计编程思想，通过封装、继承、多态把程序的耦合度降低，将功能按块儿进行划分，降低彼此之间的耦合度。而设计模式使得程序更加灵活，容易修改，并且易于复用。

对于计算器这个程序，我们本可以直接用计算机能够理解的逻辑来描述和表达解决的问题及具体的求解过程。先要求输入两个数和运算符号，然后根据运算符号判断选择如何运算，得到结果。这样算根本没有什么错误，也能够很好的实现我们当时所需的功能。

但是这样的不容易维护，不容易扩展，更不容易复用。当我们需要增加平方根、立方根、自然对数、正弦余弦等运算的时候，修改起来比较复杂，一不小心会修改错，导致其他的功能出现错误。

下面是运用工厂模式，只要输入运算符号，工厂就实例化出合适的对象，通过多态返回父类的方式实现计算结果。

首先是Operation运算类。该类中包含两个用于计算器前后数的可读可写的属性和一个虚方法

 

    #region Operation运算类
    public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        //NumberA是一个属性，该属性有两个方法：get和set
        public double NumberA
        {
            get { return _numberA; }
            set {_numberA =value; }
        }
        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        //GetResult是一个方法，虚方法
        public virtual double GetResult()
        { 
            double result=0;
            return result;
        }
    }
    #endregion

 

接下来分别用加减乘除四个类去继承上面的运算类，重写父类的虚方法

 

    #region 加法类继承运算类
    class OperationAdd : Operation
    {
        //重写父类中GetResult虚方法，定义为加法
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    #endregion
    #region 减法类继承运算类
    class OperationSub : Operation
    {
        //重写父类中GetResult虚方法，定义为减法
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    #endregion
    #region 乘法继承运算类
    class OperationMul : Operation
    {
        //重写父类中GetResult虚方法，定义为乘法
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    #endregion

 

写完这五个类，但是问题也来了，我么如何让计算器知道我我们用哪一个算法呢？下面就要用到简单工厂模式：

 

    #region 简单工厂
    //只需要输入运算符，工厂就会实例化出合适的对象，通过多态返回父类的方式实现了计算器的结果
    public class OperationFactory
    {
        public static Operation createOperate(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;
        }
    }
    #endregion

 

客户端的代码指需要这样：

 

    #region 客户端代码
    class Program
    {
        //通过多态，返回父类的方式实现了计算器的结果
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA =1;
            oper.NumberB=2;
            double result=oper.GetResult ();
            Console.WriteLine("您的运算结果是:"+result );
            Console.ReadLine();
        }
    }

 

通过以上的代码，我们就很好的将计算部分和显示部分分开了。我们再增加算法的时候，只需按照加减乘除四个类增加相应的类，在再格式工厂中增加相应的判断分支就好了。