面向对象中多态的理解

面向对象三大特征：封装、继承、多态。
今天，我们来了解一下多态。

什么是多态

多态指同一个实体同时具有多种形式，指为不同数据类型的实体提供统一的接口。它是面向对象程序设计（OOP）的一个重要特征。
eg：品鉴师要品菜，一号厨师煮出了淮扬菜，二号厨师炒了东北菜。
多态有两个重要的概念：动态绑定和方法重写。

动态绑定：在运行时，系统根据实际对象的类型来决定调用哪个方法。这使得程序能够根据实际情况进行灵活的调用。

方法重写：子类可以重写父类中的方法，以提供自己的实现。当通过父类引用调用重写方法时，实际执行的是子类中的方法。

多态的好处

主要是利于代码扩展

多态的类型

分为运行时的多态和编译时的多态
运行时的多态：通过覆写虚成员实现。直到系统运行时，才根据实际来决定实现哪种操作
编译时的多态：通过重载来实现。根据传递的参数、返回的类型等信息决定实现何种操作

多态的示例

结合设计模式

运算类（父类）

    public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;
 
        /// <summary>
        /// 数字A
        /// </summary>
        public double NumberA
        {
            get
            {
                return _numberA;
            }
            set
            {
                _numberA = value;
            }
        }
 
        /// <summary>
        /// 数字B
        /// </summary>
        public double NumberB
        {
            get
            {
                return _numberB;
            }
            set
            {
                _numberB = value;
            }
        }
 
        /// <summary>
        /// 得到运算结果
        /// </summary>
        /// <returns></returns>
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }

加法、减法（子类）

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

利用简单工厂实例化对象

public class OperationFactory
{
    public static Operation createOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
            case "+":
                {
                    oper = new OperationAdd();
                    break;
                }
            case "-":
                {
                    oper = new OperationSub();
                    break;
                }
        }
        return oper;
    }
}

main程序

static void Main(string[] args)
{
    Operation oper;
    oper = OperationFactory.createOperate("+");//通过简单工厂创建对象
    oper.NumberA = 1;
    oper.NumberB = 2;
    double result = oper.GetResult();
    Console.WriteLine(result);
}

所以通过上面的例子得出多态实现机制主要表现：在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

简单代码示例

下面是一个简单的代码示例来说明多态的工作原理：

// 定义一个动物类
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 定义一个狗类继承自动物类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗在汪汪叫");
    }
}

// 定义一个猫类继承自动物类
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫在喵喵叫");
    }
}

// 测试多态
public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 使用父类引用指向子类对象
        Animal animal2 = new Cat(); // 使用父类引用指向子类对象

        animal1.makeSound(); // 调用子类的方法
        animal2.makeSound(); // 调用子类的方法
    }
}

在上面的示例中，我们定义了一个 Animal 类作为父类，并分别定义了 Dog 和 Cat 类作为子类。子类重写了父类的 makeSound 方法。

在 PolymorphismExample 类的 main 方法中，我们使用父类引用指向子类对象。当调用 makeSound 方法时，实际执行的是子类中重写的方法。

输出结果：

狗在汪汪叫
猫在喵喵叫

通过多态，我们可以使用统一的方式来处理不同类型的对象，而不需要为每个具体类型编写单独的代码。这使得程序更加灵活和易于扩展。

多态的优势

多态有以下几个优势：

可扩展性：通过多态，可以轻松添加新的子类，而不需要修改已有的代码。这使得程序更具可扩展性。

可维护性：多态使得代码更具可读性和简洁性。通过使用父类引用来处理不同类型的对象，可以使代码更易于理解和维护。

代码重用：多态通过将共同的行为放在父类中，可以实现代码的重用。子类只需要覆盖需要特殊化的方法，而不需要重新实现所有方法。

通过合理应用多态的概念，可以提高代码的可维护性、可扩展性和重用性，使程序更加灵活和易于开发。多态是面向对象编程中一个重要的特性，值得我们深入理解和应用。