面向对象的编程的实施例

        以前的博客主要是理论介绍面向对象编程，过一个计算器的实例来学习面向对象的优点。

       依照面向对象的三大特征：

       1、封装

        对事物的状态和行为的细节封装，这样就形成了一个能够反复使用的“零件”，这样就使得我们写的代码可复用，以下是计算器的代码展示，把计算器的业务逻辑与界面逻辑分开：    

///业务逻辑——OPeration运算类
public 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 "/":
                    result = numberA / numberB;
                    break;
            }
            return result;
        }
    }

///界面逻辑——client代码 
static void Main (string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            ///对界面进行设计定义
            try 
            {
                Console.Write("请输入数字A:");
                string strNumberA = Console.ReadLine();
                Console.Write("请选择运算符号（+、-、*、/）：");
                string strOperate = Console.ReadLine();
                Console.Write("请输入数字B:");
                string strNumberB=Console.ReadLine();
                string strResult="";
                strResult = Convert.ToString(Operation.GetResult(Convert.ToDouble(strNumberA), Convert.ToDouble(strNumberB), strOperate));
                Console.WriteLine("结果是：" + strResult);
                Console.ReadLine();
            }
            catch (Exception ex)     ///错误信息提示
            {
                Console.WriteLine("您的输入有错：" + ex.Message);   
            }
            
        }

这样。我们就能够自由的改动类的内部。用户假设想写一个其它版的程序，既能够直接复用这个Operation运算类。

         2、继承        

class OperationAdd : Operation    ///加法类，继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation   ///减法类。继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA -NumberB;
            return result;
        }
    }
    class OperationMul : Operation   ///乘法类，继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperationDiv : Operation   ///除法类。继承运算类
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0.");
            result = NumberA / NumberB;
            return result;
        }
    }

加减乘除是运算方法类，执行时的代码大部分都同样，把同样的代码都放到父类运算类（OPeration）中，这样写代码的时候反复的部分就能够不用写，直接从父类中继承即可，并且假设不用继承。当你改动功能。就必须在全部反复的方法中改动，代码越多。出错的可能就越大。

        3、多态

        我们建一个简单运算工厂。这个工厂的功能生产各种运算。加减乘除。平方根，立方根，自然对数，正弦余弦...

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

各种运算都是子类，他们都有一个共同的父类运算类（Operation），尽管每一种运算也是一种类，可是他们的终于结果是把几个数的运算结果算出来。

这样我们就实现了我们所写的程序可维护、可扩展、可复用、灵活性好的功能。

 

       

版权声明：本文博客原创文章。博客，未经同意，不得转载。