前言：多态是面向对象编程中的一个重要概念，它允许我们在不同的对象上调用相同的方法，但根据对象的不同，可以产生不同的行为。在 Java 中，多态性是一个强大的特性，它有助于代码的可扩展性和可维护性。
先让我们看一下本篇文章的大致内容：
为了更好地理解多态，我们需要掌握以下核心概念：（先进行了解即可）
- 方法重写（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中的多态之后，那么为什么要使用多态呢？
多态的优点：
- 代码重用： 可以使用通用的接口来操作不同类型的对象，从而减少了代码的重复编写。
- 灵活性： 可以轻松地扩展程序，添加新的子类而无需修改现有的代码。
- 可维护性： 通过多态，我们可以将代码组织得更加清晰和易于维护。
- 简化接口： 多态性允许我们使用通用接口，而不必关心对象的具体类型。
- 提高代码的可读性： 代码更易于理解，因为它更符合现实世界的模型。
当然多态在日常生活中也有许多的实际用处，只不过我们需要将其转换为代码的形式而已，例如：
- 图形绘制： 图形绘制程序可以使用多态性来处理不同类型的图形对象，如圆形、矩形和三角形。
- 汽车制造： 汽车制造公司可以使用多态性来处理不同型号和品牌的汽车，从而简化生产流程。
- 动态插件： 软件应用程序可以使用多态性来支持动态加载和卸载插件，从而增加灵活性。
- 电子商务： 电子商务平台可以使用多态性来处理不同类型的商品和付款方式。
- 游戏开发： 游戏开发中的角色和道具可以使用多态性来实现不同的行为。
这样我们就了解了什么是java中的多态了。
