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

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

[csharp]   view plain copy

1. try  
2.             {  
3.                 Console.WriteLine("请输入数字A：");  
4.                 string numberA = Console.ReadLine();  
5.                 Console.WriteLine("请输入计算字符“+,-,*,/”");  
6.                 string operater = Console.ReadLine();  
7.                 Console.WriteLine("请输入数字B：");  
8.                 string numberB = Console.ReadLine();  
9.   
10.   
11.                 double strRusult=0;  
12.   
13.                 if (operater == "+")  
14.                 {  
15.                     strRusult = Convert.ToDouble(numberA) + Convert.ToDouble(numberA);  
16.                 }  
17.                 else if (operater == "-")  
18.                 {  
19.                     strRusult = Convert.ToDouble(numberA) - Convert.ToDouble(numberA);  
20.                 }  
21.                 else if (operater == "*")  
22.                 {  
23.                     strRusult = Convert.ToDouble(numberA) * Convert.ToDouble(numberA);  
24.                 }  
25.                 else if (operater == "/")  
26.                 {  
27.                     if (Convert.ToDouble( numberB) != 0)  
28.                     {  
29.                         strRusult = Convert.ToDouble(numberA) / Convert.ToDouble(numberA);  
30.                     }  
31.                     else  
32.                     {  
33.                         throw new Exception("除数不能为零！");  
34.                     }  
35.                 }  
36.   
37.   
38.                 Console.WriteLine("计算机果是" + strRusult.ToString());  
39.                 Console.ReadKey();  
40.             }  
41.             catch (Exception ex)  
42.             {  
43.                 throw new Exception(ex.Message, ex);  
44.             }  

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

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

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

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class Operation  
4.     {  
5.         public static double GetResult(double numberA, double numberB, string operate)  
6.         {  
7.             double result = 0d;  
8.   
9.             switch (operate)  
10.             {  
11.                 case"+":  
12.                     {  
13.                         result = numberA + numberB;  
14.                     }  
15.                     break;  
16.                 case "-":  
17.                     {  
18.                         result = numberA - numberB;  
19.                     }  
20.                     break;  
21.                 case"*":  
22.                         {  
23.                             result = numberA * numberB;  
24.                         }  
25.                         break;  
26.                 case"/":  
27.                         {  
28.                             if(numberB!=0)  
29.                             {  
30.                                 result=numberA/numberB;  
31.                             }  
32.                             else  
33.                             {  
34.                                 Console.WriteLine("除数不能为零！");  
35.                             }  
36.                         }  
37.                     break;  
38.             }  
39.             return result;  
40.         }  
41.     }  
42. }  

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

[csharp]   view plain copy

1. try  
2.             {  
3.                 Console.WriteLine("请输入数字A：");  
4.                 string numberA = Console.ReadLine();  
5.                 Console.WriteLine("请输入计算字符“+,-,*,/”");  
6.                 string operater = Console.ReadLine();  
7.                 Console.WriteLine("请输入数字B：");  
8.                 string numberB = Console.ReadLine();  
9.   
10.   
11.                 string strRusult = "";  
12.                 strRusult = Convert.ToString(Operation.GetResult(Convert.ToDouble(numberA), Convert.ToDouble(numberB), operater));  
13.   
14.                 Console.WriteLine("计算机果是" + strRusult);  
15.                 Console.ReadKey();  
16.             }  
17.             catch (Exception ex)  
18.             {  
19.                 throw new Exception(ex.Message, ex);  
20.             }  

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

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

代码结构：

代码如下：

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

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class Operation1  
4.     {  
5.         private double _numberA = 0;  
6.         private double _numberB = 0;  
7.   
8.         public double NumberA  
9.         {  
10.             get { return _numberA; }  
11.             set { _numberA = value; }  
12.         }  
13.   
14.         public double NumberB  
15.         {  
16.             get { return _numberB; }  
17.             set { _numberB = value; }  
18.         }  
19.   
20.         public virtual double GetResult()  
21.         {  
22.             double result = 0;  
23.             return result;  
24.         }  
25.     }  
26. }  

OperationAdd.cs类实现加法运算：

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class OperationAdd:Operation1  
4.     {  
5.         public override double GetResult()  
6.         {  
7.             double result = 0;  
8.             result = NumberA + NumberB;  
9.             return result;  
10.         }  
11.     }  
12. }  

OperationSub.cs类实现减法运算：

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class OperationSub:Operation1  
4.     {  
5.         public override double GetResult()  
6.         {  
7.             double result = 0;  
8.             result = NumberA - NumberB;  
9.   
10.   
11.             return result;  
12.             //return base.GetResult();  
13.         }  
14.     }  
15. }  

OperationMul.cs类实现乘法运算：

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class OperationMul:Operation1  
4.     {  
5.         public override double GetResult()  
6.         {  
7.             double result = 0;  
8.             result = NumberA * NumberB;  
9.             return result;  
10.             //return base.GetResult();  
11.         }  
12.     }  
13. }  

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

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class OpetionDiv:Operation1  
4.     {  
5.         public override double GetResult()  
6.         {  
7.             double result = 0;  
8.   
9.             if (NumberB != 0)  
10.             {  
11.                 result = NumberA / NumberB;  
12.             }  
13.             else  
14.             {  
15.                 //throw new Exception("除数不能为零！");  
16.                 Console.WriteLine("除数不能为零！");  
17.             }  
18.             return result;  
19.             //return base.GetResult();  
20.         }  
21.     }  
22. }  

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

[csharp]   view plain copy

1. namespace 面向对象的计算器  
2. {  
3.     class OperationFactory  
4.     {  
5.         public static Operation1 creatOperation(string operate)  
6.         {  
7.             Operation1 oper = null;  
8.   
9.             switch (operate)  
10.             {  
11.                 case "+":  
12.                     {  
13.                         oper = new OperationAdd();  
14.                         break;  
15.                     }  
16.                 case "-":  
17.                     {  
18.                         oper = new OperationSub();  
19.                         break;  
20.                     }  
21.                 case "*":  
22.                     {  
23.                         oper = new OperationMul();  
24.                         break;  
25.                     }  
26.                 case "/":  
27.                     {  
28.                         oper = new OpetionDiv();  
29.                         break;  
30.                     }  
31.             }  
32.             return oper;  
33.         }  
34.     }  
35. }  

主函数中进行调用：

[csharp]   view plain copy

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

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