简单计算器的面向过程实现和面向对象实现对比

1）首先使用C#的面向过程的编写代码实现了简单计算器的计算，代码如下：

try            {                Console.WriteLine("请输入数字A：");                string numberA = Console.ReadLine();                Console.WriteLine("请输入计算字符“+,-,*,/”");                string operater = Console.ReadLine();                Console.WriteLine("请输入数字B：");                string numberB = Console.ReadLine();                double strRusult=0;                if (operater == "+")                {                    strRusult = Convert.ToDouble(numberA) + Convert.ToDouble(numberA);                }                else if (operater == "-")                {                    strRusult = Convert.ToDouble(numberA) - Convert.ToDouble(numberA);                }                else if (operater == "*")                {                    strRusult = Convert.ToDouble(numberA) * Convert.ToDouble(numberA);                }                else if (operater == "/")                {                    if (Convert.ToDouble( numberB) != 0)                    {                        strRusult = Convert.ToDouble(numberA) / Convert.ToDouble(numberA);                    }                    else                    {                        throw new Exception("除数不能为零！");                    }                }                Console.WriteLine("计算机果是" + strRusult.ToString());                Console.ReadKey();            }            catch (Exception ex)            {                throw new Exception(ex.Message, ex);            }

在此过程中的缺点很明显就是在每次的计算过程中，都要对每个运算符进行if语句的验证，而且代码是不可以重用的，很是繁琐，不利于后期的功能添加和维护。

2）使用面像对象的思想对验证和的方法进行封转，使，展示层和逻辑运算代码层进行分割，然后在主运算层进行调用，代码，如下：

首先，定义一个Operation的类，其中的代码如下：

namespace 面向对象的计算器{    class Operation    {        public static double GetResult(double numberA, double numberB, string operate)        {            double result = 0d;            switch (operate)            {                case"+":                    {                        result = numberA + numberB;                    }                    break;                case "-":                    {                        result = numberA - numberB;                    }                    break;                case"*":                        {                            result = numberA * numberB;                        }                        break;                case"/":                        {                            if(numberB!=0)                            {                                result=numberA/numberB;                            }                            else                            {                                Console.WriteLine("除数不能为零！");                            }                        }                    break;            }            return result;        }    }}

定义玩相应的类以后，在主界面进行调用，代码如下：

try            {                Console.WriteLine("请输入数字A：");                string numberA = Console.ReadLine();                Console.WriteLine("请输入计算字符“+,-,*,/”");                string operater = Console.ReadLine();                Console.WriteLine("请输入数字B：");                string numberB = Console.ReadLine();                string strRusult = "";                strRusult = Convert.ToString(Operation.GetResult(Convert.ToDouble(numberA), Convert.ToDouble(numberB), operater));                Console.WriteLine("计算机果是" + strRusult);                Console.ReadKey();            }            catch (Exception ex)            {                throw new Exception(ex.Message, ex);            }

这样完成对运算符验证的封装，而且使用Switch语句，对运算符进行验证，不用每次对每个运算符都进行验证，节省代码，可以代码重用。

另外，体现完全面像对象思想的简单计算器的计算，就是定义一个计算类，具有相应计算的属性，课计算的虚方法。分别定义相应的计算的类，然后，在进行计算时候调用，相应的类，并且对类中包含方法进行重写，实现，封装，继承，多态的思想，

代码结构：

代码如下：

定义的   Operation1.cs父类，其他的计算方法从该类进行继承，

namespace 面向对象的计算器{    class Operation1    {        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;        }    }}

OperationAdd.cs类实现加法运算：

namespace 面向对象的计算器{    class OperationAdd:Operation1    {        public override double GetResult()        {            double result = 0;            result = NumberA + NumberB;            return result;        }    }}

OperationSub.cs类实现减法运算：

namespace 面向对象的计算器{    class OperationSub:Operation1    {        public override double GetResult()        {            double result = 0;            result = NumberA - NumberB;            return result;            //return base.GetResult();        }    }}

OperationMul.cs类实现乘法运算：

namespace 面向对象的计算器{    class OperationMul:Operation1    {        public override double GetResult()        {            double result = 0;            result = NumberA * NumberB;            return result;            //return base.GetResult();        }    }}

OpetionDiv.cs类实现除法的运算：

namespace 面向对象的计算器{    class OpetionDiv:Operation1    {        public override double GetResult()        {            double result = 0;            if (NumberB != 0)            {                result = NumberA / NumberB;            }            else            {                //throw new Exception("除数不能为零！");                Console.WriteLine("除数不能为零！");            }            return result;            //return base.GetResult();        }    }}

OperationFactory.cs类，来判断主函数应该调用哪个类进行运算：

namespace 面向对象的计算器{    class OperationFactory    {        public static Operation1 creatOperation(string operate)        {            Operation1 oper = null;            switch (operate)            {                case "+":                    {                        oper = new OperationAdd();                        break;                    }                case "-":                    {                        oper = new OperationSub();                        break;                    }                case "*":                    {                        oper = new OperationMul();                        break;                    }                case "/":                    {                        oper = new OpetionDiv();                        break;                    }            }            return oper;        }    }}

主函数中进行调用：

      Operation1 oper = new Operation1();            oper = OperationFactory.creatOperation("+");            oper.NumberA = 1;            oper.NumberB = 2;            double result = oper.GetResult();            Console.WriteLine("计算结果为：" + result);            Console.ReadKey();

最后完全使用面向对象的思想，实现封装，继承，多态的思想。每一块的代码，都是可以重用，每个部分单独成块，互不影响。