抽象方法实现计算器

前面我们用面向对象的思想简单的实现了计算器。见http://www.cnblogs.com/wesley168/p/6226747.html。其实这里还是有其他问题的。

比如：现在我要除了要实现加减乘除外，还要添加其他运算，就需要修改switch中的代码。这违背了开闭原则（对修改关闭，对扩展开放）。

我们每次操作计算器的时候，都会输入两个数字，选择一个运算符，这是反复出现的。所以我们把输入的两个数字，运算符封装到一个类中，该类只实现一种运算。

由于每个类都要有两个数字，并且有个计算方法，但是这个方法在使用前并不知道里面是如何实现。所以我们把这个类设计成抽象类，里面的计算方法设计成抽象方法。代码如下：

 public abstract class Calc
    {
        public int Number1 { get; set; }

        public int Number2 { get; set; }
        public Calc(int n1,int n2)
        {
            this.Number1 = n1;
            this.Number2 = n2;
        }

        public abstract double Calculate();
    }

控制台中的代码如下：

static void Main(string[] args)
        {
            while (true)
            {
                Console.Write("请输入第一个数字： ");
                int n1 = Convert.ToInt32(Console.ReadLine());

                Console.Write("请输入运算符： ");
                string sign = Console.ReadLine();

                Console.Write("请输入第二个数字：");
                int n2 = Convert.ToInt32(Console.ReadLine());

                Calc c = GetCalcResult(n1, sign, n2);

                Console.WriteLine("结果是：{0}", c.Calculate());

            }

            //Console.ReadKey();
        }

这里进一步把switch中的代码封装成了一个简单工厂的核心方法。如果需要添加运算操作，可以直接添加每个运算对应的类，如：

加法：

public class Add : Calc
    {
        public Add(int n1, int n2) : base(n1, n2)
        {
        }

        public override double Calculate()
        {
            return this.Number1 + this.Number2;
        }
    }

减法：

public class Sub : Calc
    {
        public Sub(int n1, int n2) : base(n1, n2)
        {
        }

        public override double Calculate()
        {
            return this.Number1 - this.Number2;
        }
    }

乘法：

public class Mul : Calc
    {
        public Mul(int n1, int n2) : base(n1, n2)
        {
        }

        public override double Calculate()
        {
            return this.Number1 * this.Number2;
        }
    }

除法：

public class Div : Calc
    {
        public Div(int n1, int n2) : base(n1, n2)
        {
        }

        public override double Calculate()
        {
            throw new NotImplementedException();
        }
    }

可能有人会问了，如果再添加新的运算符，还是需要更改switch中的方法。这里可以使用反射进一步优化。具体后面会进一步讲解。