面向对象——多态

面向对象的多态

一、概述

多态是面向对象编程中的一个重要概念，它允许不同类型的对象对同一消息做出不同的响应。多态性使得程序可以以一种统一的方式处理不同类型的对象，提高了代码的灵活性和可扩展性。

二、多态的实现方式

2.1 静态多态

静态多态是通过函数重载和运算符重载来实现的。函数重载允许在同一个类中定义多个同名函数，但参数类型或个数不同。运算符重载允许对已有的运算符进行重新定义，使其适用于自定义的类类型。

2.2 动态多态

动态多态是通过继承和虚函数来实现的。继承允许一个类派生出多个子类，子类可以重写父类的成员函数。虚函数是在基类中声明为虚函数的成员函数，它可以在派生类中被重写，并通过基类指针或引用调用派生类的函数。

三、多态的优点

3.1 代码复用

多态性使得不同类型的对象可以共享相同的接口和行为，从而提高了代码的复用性。通过定义一个通用的接口，可以在不同的类中实现不同的功能，减少了代码的重复编写。

3.2 扩展性

多态性使得程序可以轻松地扩展新的类和功能。通过继承和虚函数的机制，可以定义新的子类，并在不修改已有代码的情况下添加新的功能。

3.3 灵活性

多态性使得程序可以以一种统一的方式处理不同类型的对象。通过基类指针或引用调用派生类的函数，可以在运行时确定要调用的函数，从而实现动态绑定和动态调用。

四、多态的应用场景

4.1 多态的参数和返回类型

多态性可以在函数参数和返回类型中使用，提高了代码的灵活性和可扩展性。通过使用基类指针或引用作为函数参数和返回类型，可以接受或返回不同类型的对象。

4.2 多态的容器和算法

多态性可以应用于容器和算法中，实现对不同类型的对象进行统一的管理和操作。通过使用容器和算法的泛型化设计，可以在运行时确定要处理的对象类型。

4.3 多态的事件和消息处理

多态性可以应用于事件和消息处理中，实现对不同类型的事件和消息进行统一的处理。通过定义统一的事件和消息接口，可以在不同的类中实现相应的处理函数。

       可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

多态的主要用途

1、提高程序的可扩展性；
2、降低系统耦合度；
3、提高系统的可维护性。

示例

       结合大话设计模式，第9页-第11页的代码，通过简单工厂模式实现计算器小程序,深刻理解面向对象的多态。

Operation-运算类

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

OperationFactory-简单运算工厂类

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

OperationAdd-加法类

class OperationAdd:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

OperationSub-减法类

public class OperationSub:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

OperationMul-乘法类

class OperationMul:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result; 
        }
    }

OperationDiv-除法类

class OperationDiv:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB==0)
            {
                throw new Exception("除数不能为0.");
            }
            result = NumberA + NumberB;
            return result;
        }
    }

客户端代码

 Operation oper;
    oper = OperationFactory.createOperate("+");
    oper.NumberA = 1;
    oper.NumberB = 2;
    double result = oper.GetResult();
    Console.WriteLine(result);
    

       根据代码可知，Operation类是父类，加减乘除是Operation的子类。在各个子类中重写了父类中的GetResult方法，对于父类的同一个方法，各个子类有不同的实现，符合多态的概念。

多态的前提

多态的前提：必须是类与类之间有关系。要么继承，要么实现。
多态（英语：polymorphism）：指为不同数据类型的实体提供统一的接口。把概念对应到代码上，如下图所示：

在上图中OperationAdd、OperationSub、OperationMul和OperationDiv对应到概念上是不同数据类型的实体。

不同的数据类型的实体有相同的方法（统一的接口），方法有不同的实现。在这里GetResult是加减乘除类的相同的方法。

五、总结

多态是面向对象编程中的一个重要概念，通过函数重载、运算符重载、继承和虚函数实现。多态性提高了代码的灵活性、可扩展性和复用性，使得程序可以以一种统一的方式处理不同类型的对象。多态性可以应用于参数和返回类型、容器和算法、事件和消息处理等场景中。通过合理应用多态性，可以提高代码的可读性、可维护性和可扩展性。