Java多态（如果想知道Java中有关多多态的知识点，那么只看这一篇就足够了！）

为了更好地理解多态，我们需要掌握以下核心概念：（先进行了解即可）

1. 方法重写（Override）： 子类可以提供对父类中已有方法的新实现。在子类中重新定义一个与父类中方法名、参数列表和返回类型相同的方法，从而覆盖（重写）了父类中的方法。
   向上转型（Upcasting）： 可以将子类的对象引用赋给父类类型的变量，这被称为向上转型。这样做可以让我们在父类引用上调用子类的方法，从而实现多态性。
   动态绑定（Dynamic Binding）： 运行时多态性的关键概念之一。它意味着方法的调用是在程序运行时根据对象的实际类型来确定的，而不是在编译时。
   instanceof 运算符： 用于检查一个对象是否是特定类的实例。它可以帮助我们在运行时确定对象的类型，从而进行适当的操作。

为了理解学习多态，让我们先学习一下这些核心知识，接下来我们将一一学习它们。

1.向上转型+向下转型

       先来让我们认识一下什么是向上转型和向下转型。

       （1）向上转型

       向上转型（Upcasting）： 将子类的对象引用赋给父类类型的变量，这被称为向上转型。其作用为可以让我们在父类引用上调用子类的方法，从而实现多态性。

了解完了什么是向上转型之后，让我们看一个向上转型的例子来进一步理解：

//父类Animal
class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
//子类Dog
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
 
public class Test {
    public static void main(String[] args) {
        // 创建一个Dog对象
        Dog myDog = new Dog();
 
        // 向上转型：将Dog对象赋值给Animal引用
        Animal myAnimal = myDog; // 这就是向上转型
    }
}

       在这个例子中，我们有一个Animal类和一个Dog类，其中Dog是Animal的子类。在main方法中，我们创建了一个Dog对象，并将其赋值给一个Animal类型的引用myAnimal，这就是向上转型的一个例子。

了解了什么是向上转型之后，在让我们看一下什么是向下转型。

       （2）向下转型

        向下转型（downcasting）：将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时，将父类引用再还原为子类对象即可，即向下转换。

了解了什么是向下转型，现在让我们使用一个向下转型的例子来进一步理解（还是继续使用上面的案例）：

//父类Animal
class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
//子类Dog
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
 
public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal myAnimal = new Dog();
 
        // 检查myAnimal是否真的是Dog的一个实例  
        if (myAnimal instanceof Dog) {
            // 向下转型：将Animal引用转换为Dog引用  
            Dog myDog = (Dog) myAnimal; // 这就是向下转型  
        } else {
            //如果不是Dog类
            System.out.println("myAnimal is not a Dog");
        }
    }
}

       在这个例子中，我们首先创建了一个Dog对象，并将其赋值给了一个Animal类型的引用myAnimal。然后，我们使用instanceof操作符来检查myAnimal是否真的是Dog的一个实例。如果是，我们就可以安全地进行向下转型，将myAnimal转换为Dog类型的引用myDog,如果不是，则返回 “myAnimal is not a Dog”

补充：instanceof

       在这个案例中我们看到出现了一个关键词instanceof，那么instanceof的作用是什么呢？

目前我们可以理解instanceof的作用为：

       instanceof是一个运算符，其用于测试对象是否是一个类的实例。

instanceof使用的语法形式为：

if (object instanceof Class) {
    // object 是 Class 类型或其子类的实例
}

这样我们就大致的了解了什么是向上转型和向下转型了。

2.方法重写

       方法重写是Java多态中的核心步骤之一，那么什么是方法重写呢？

       方法重写（Override）： 即子类可以提供对父类中已有方法的新实现。在子类中重新定义一个与父类中方法名、参数列表和返回类型相同的方法，从而覆盖（重写）了父类中的方法。

       嗯嗯嗯......看是大致看懂了，但是还是不是太理解，接下来我们使用实例来帮助你进一步理解什么是方法重写（继续使用上面的案例）：

//父类Animal
class Animal {
    void makeSound(String name) {
        System.out.println("The animal makes a sound");
    }
}
//子类Dog
class Dog extends Animal {
    
    //对父类的方法重写
    @Override
    void makeSound(String name) {
        System.out.println("The dog barks");
    }
}

       我们可以看到子类Dog继承了其父类Animal，并且也创建了一个同父类中的makeSound（）方法相同的方法，只不过内部的实现有所区别，这就是方法的重写。

       注意： 子类在重写父类的方法时，一般必须与父类方法原型一致： 即返回值类型，方法名，参数列表要完全一致（如图）：

当然，对于Java中的方法重写，还有许多需要注意的事项：

1. 被重写的方法返回值类型可以不同，但是必须是具有父子关系;

2. 子类的访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected；

3. 父类被static、private修饰的方法、构造方法都不能被重写；

4. 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.；

这样我们就大致的了解了什么是方法重写了。

3.静态绑定+动态绑定

       讲到多态时，我们都会提及静态绑定和动态绑定，那么什么是静态绑定、动态绑定呢？

       （1）静态绑定

       静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。

其中最常见的例子就是方法的重载（例如）：

// 第一个重载方法，没有参数
    public void display() {
        System.out.println("No parameters passed.");
    }
 
    // 第三个重载方法，接受一个字符串参数
    public void display(String message) {
        System.out.println("A string parameter: " + message);
    }
 
    // 第三个重载方法，接受两个整数参数
    public void display(int num1, int num2) {
        System.out.println("Two integer parameters: " + num1 + " and " + num2);
    }

在调用这些方法的时候，我们可以在编译的时候就知道调用的是哪一个方法（因为它们的参数不同），这就是静态绑定。

       （2）动态绑定

       动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

其中最常见的例子就是多态中的方法的调用，这里先不进行讲解，下文合适时会提及。

这样我们就大致的了解了什么是静态绑定和动态绑定了。

4.多态

       铺垫了这么多的知识，终于到了本文最重要，最核心的知识了——什么是Java中的多态？

先让我们了解一下多态的定义：

       多态（Polymorphism）是面向对象编程的核心概念之一。它源于希腊语，意为“多种形态”。多态性使得我们可以使用通用的接口来表示不同的对象，并且能够在运行时确定对象的具体类型，从而调用相应的方法。

鹅鹅鹅......没看懂，那么我们接下来使用更加平易近人的方式来描述一下什么是多态：

       通俗来说，多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

为了更好的使你了解什么是多态，我们使用一个案例进行讲解（每一步都有详解）：

// 定义一个基类（父类）
class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
// 定义一个派生类（子类），继承自Animal类
class Dog extends Animal {
    // 重写父类的方法
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
// 另一个派生类（子类），也继承自Animal类
class Cat extends Animal {
    // 重写父类的方法
    @Override
    void makeSound() {
        System.out.println("The cat meows");
    }
}
 
// 主类，用于演示多态
public class Test {
    public static void main(String[] args) {
        //创建两个对象，一个为Dog类，一个为Cat类
        Animal animalDog = new Dog();
        Animal animalCat = new Cat();
 
        //分别调用makeSound方法
        animalDog.makeSound();
        animalCat.makeSound();
    }
}

当你运行这个Test方法时，你会看到控制台输出了以下结果：

       通过这个案例，我们就知道了Java中多态是如何工作的，我们尽管都是调用了父类（Animal）的makeSound方法，但是最终调用的为其子类中对其重写的方法，这就是所谓的Java中的多态。

不知道你是否还记得上文中提及的动态绑定，这也是一个动态绑定的例子：

       动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

       我们在编译的时候，都是调用的其父类的makeSound方法，这就是在编译时，不能确定方法的行为，但是当我们运行后，其就会调用特定对象中的方法，，即需要等到程序运行时，才能够确定具体调用那个类的方法。

       ——了解了Java中的多态之后，那么为什么要使用多态呢？

多态的优点：

1. 代码重用： 可以使用通用的接口来操作不同类型的对象，从而减少了代码的重复编写。
2. 灵活性： 可以轻松地扩展程序，添加新的子类而无需修改现有的代码。
3. 可维护性： 通过多态，我们可以将代码组织得更加清晰和易于维护。
4. 简化接口： 多态性允许我们使用通用接口，而不必关心对象的具体类型。
5. 提高代码的可读性： 代码更易于理解，因为它更符合现实世界的模型。

当然多态在日常生活中也有许多的实际用处，只不过我们需要将其转换为代码的形式而已，例如：

1. 图形绘制： 图形绘制程序可以使用多态性来处理不同类型的图形对象，如圆形、矩形和三角形。
2. 汽车制造： 汽车制造公司可以使用多态性来处理不同型号和品牌的汽车，从而简化生产流程。
3. 动态插件： 软件应用程序可以使用多态性来支持动态加载和卸载插件，从而增加灵活性。
4. 电子商务： 电子商务平台可以使用多态性来处理不同类型的商品和付款方式。
5. 游戏开发： 游戏开发中的角色和道具可以使用多态性来实现不同的行为。

这样我们就了解了什么是java中的多态了。