c#，用面向对象思想写一个计算器

      设计模式的第一个例子之后，我再次体会到了做一个软件，不仅仅是为了功能的实现，更多的是“为人民服务”！

      不用面向对象的方法去写，要实现一个简单的只有“+ - * /”计算器，那是相当简单的，只需获取用户输入的数字和运算符，然后“A运算B”得出结果显示出来就行了。如下代码所示：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

	    //输入要运算的数字和运算符
            Console.WriteLine("请输入数字A");
            double A =Convert .ToDouble ( Console.ReadLine());
            Console.WriteLine("请输入运算符");
            string operate = Console.ReadLine();
            Console.WriteLine("请输入数字B");
            double B = Convert.ToDouble(Console.ReadLine());

	    //将结果存储到变量D里面
            double D=0;

	    //用if条件语句判断输入的符号而进行相应的运算并输出
            if (operate =="+")
            {
                D = A + B;
                Console.WriteLine("A+B=" + D);

            }
            if (operate =="-")
            {
                D = A - B;
                Console.WriteLine("A-B=" +D);
            }
            if  (operate =="*")
            {
                D = A * B;
                Console.WriteLine("A*B=" +D);
            }
            if (operate =="/")
            {
                D = A / B;
                Console.WriteLine("A/B=" + D);
            }
        }
    }
}

      如果用户的需求发生了变化了呢？比如想再加个开根号的运算，然后就加个if语句，在输入项里也要改动，而且当除数为零时，还会发生错误，直接导致程序死掉，这些变化的产生，对于修改程序是一件非常麻烦的事，小程序还好，大程序的话就特别容易导致错误的发生，而且不易于修改，很可能修改一个地方，却导致了另一个地方出现问题，这种整个程序的程序块与程序块之间有着组合的关系，非常不利于维护和扩展，所以，有了面向对象的思想。

      应该把整个程序抽象出一些类来，每个实现一部分功能，就如用于显示的就抽象一个显示类，运算的为运算类，还有运算符类等等，当程序需要扩展增加某项功能时候，我们只需新增一个类就行，跟别的没关系，所以非常易于维护和扩展。修改后的代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式_计算器2
{
    class Program
    {
        static void Main(string[] args)
        {
            try		//如果遇到错误，进行提示
            {

		//用于输入
                Console.WriteLine("请输入数字A");
                double _numA =Convert.ToDouble( Console.ReadLine());
                Console.WriteLine("请输入运算符（+、-、*、/）");
                string _operate = Convert.ToString ( Console.ReadLine());
                Console.WriteLine("请输入数字B");
                double _numB = Convert.ToDouble(Console.ReadLine());

                double _result;		//保存结果的变量

                Operation oper;
                oper = operationFactory.createOperate("+");
                oper.numberA = _numA;		//给类属性赋值
                oper.numberB = _numB;

                operationFactory.createOperate(_operate);
                _result = oper.GetResult();

                Console.WriteLine(_result);	//输出结果
            }
            catch
            {
                Console.WriteLine("输入有误！");
            }
            
            
        }
    }
    public class Operation			//运算父类
    {
        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;
        }
    }

    public class operationAdd:Operation		//继承运算父类的加法运算
    {
        public override double GetResult()
        {
            double result = 0;
            result = numberA + numberB;
            return result;
        }
    }

    public class operationSub:Operation		//继承运算父类的减法运算
    {
        public override double GetResult()
        {
            double result = 0;
            result = numberA - numberB;
            return result;
        }
    }

    public class operationMul:Operation		//继承运算父类的乘法运算
    {
        public override double GetResult ()
        {
            double result = 0;
            result = numberA * numberB;
            return result;
        }
    }

    public class operationDiv :Operation	//继承运算父类的除法运算
    {
        public override double GetResult()
        {
            double result;
            result = numberA / numberB;
            return result;
        }
    }

    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;
        }
    }
}

      后的程序变得层次分明，并抽象出了几个类，这样以后再需要增加功能，就直接增加类就行了，别的类根本影响不到！