一篇文章带你搞懂Java多态的概念、优点、使用场景
基本概念
**多态（Polymorphism）是面向对象编程的一个重要特性，它指的是同一个行为具有多个不同表现形式或形态的能力。**它允许我们使用父类的引用变量来引用子类的对象，并根据实际对象的类型调用相应的方法。多态就是同一个接口，使用不同的实例而执行不同操作，
如图所示：
多态性是对象多种表现形式的体现。
现实中，比如我们按下 F1 键这个动作：
- 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
- 如果当前在 Word 下弹出的就是 Word 帮助；
- 在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
上篇文章我们提到了方法的重写和重载
- 重写体现的是父类和子类的多态（也就是动态多态也称运行时多态）
- 重载体现的是一个类的多态(也就是静态多态也称编译时多态)
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象：Animal b = new Dog();
如下图：
class Shape {
void draw() {} // 父类 Shape 中的绘制方法
}
class Circle extends Shape {
void draw() { // 子类 Circle 中重写的绘制方法
System.out.println("Circle.draw()");
}
}
class Square extends Shape {
void draw() { // 子类 Square 中重写的绘制方法
System.out.println("Square.draw()");
}
}
class Triangle extends Shape {
void draw() { // 子类 Triangle 中重写的绘制方法
System.out.println("Triangle.draw()");
}
}
基类 Shape 定义了一个名为 draw 的方法，这个方法在子类中可以被重写。子类 Circle、Square 和 Triangle 分别继承自 Shape 类，并且在每个子类中都重写了 draw 方法以实现特定的绘制行为。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
以下是一个多态实例的演示，详细说明请看注释：
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat，会动态绑定到Cat类的eat()
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断，在进行向下转型之前，最好使用 instanceof 运算符进行判断，以避免类型转换异常的发生。
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a; // 向下转型
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a; // 向下转型
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
执行以上程序，输出结果为：
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
虚函数
虚函数的存在是为了多态。
**Java 中其实没有虚函数的概念，**它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。
多态的实现方式
当我们谈论多态时，通常有4种主要的方式来实现它：
1.继承和方法重写（Inheritance and Method Overriding）：
- 子类可以继承父类的方法，并且可以对该方法进行重写。
- 使用父类的引用变量来引用子类的对象，实现多态性。编译时类型为父类，运行时类型为子类。
示例：
class Animal {
void makeSound() {
System.out.println("动物发出声音");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("狗发出汪汪声");
}
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println("猫发出喵喵声");
}
}
public class Main {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // 输出 "狗发出汪汪声"
animal2.makeSound(); // 输出 "猫发出喵喵声"
}
}
2.接口实现（Interface Implementation）：
- 接口是一种将方法声明抽象化的机制，一个类可以实现一个或多个接口，并实现接口中定义的方法。
- 使用接口类型的引用变量来引用实现该接口的类的对象，实现多态性。编译时类型为接口，运行时类型为实现类。
示例：
interface Drawable {
void draw();
}
class Circle implements Drawable {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
class Square implements Drawable {
@Override
public void draw() {
System.out.println("绘制正方形");
}
}
public class Main {
public static void main(String[] args) {
Drawable shape1 = new Circle();
Drawable shape2 = new Square();
shape1.draw(); // 输出 "绘制圆形"
shape2.draw(); // 输出 "绘制正方形"
}
}
3.方法重载（Method Overloading）：
- 在同一个类中定义多个同名但参数列表不同的方法。
- 根据传入的参数类型和数量来确定调用哪个重载方法，实现多态性。
示例：
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calculator = new Calculator();
int result1 = calculator.add(2, 3); // 调用 int 版本的 add 方法
double result2 = calculator.add(2.5, 3.7); // 调用 double 版本的 add 方法
System.out.println(result1); // 输出 5
System.out.println(result2); // 输出 6.2
}
}
4.抽象类和抽象方法
- 抽象类是一种不能被实例化的类，其中可以包含抽象方法，而抽象方法是只有声明而没有具体实现的方法。
- 使用抽象类和抽象方法可以定义一个约束子类的模板，子类必须实现抽象类中声明的抽象方法。通过创建子类的对象，然后通过抽象类的引用来引用子类的对象，实现多态性。编译时类型为抽象类，运行时类型为子类。
示例：
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("绘制圆形");
}
}
class Square extends Shape {
@Override
void draw() {
System.out.println("绘制正方形");
}
}
public class Main {
public static void main(String[] args) {
Shape shape1 = new Circle();
Shape shape2 = new Square();
shape1.draw(); // 输出 "绘制圆形"
shape2.draw(); // 输出 "绘制正方形"
}
}
在上面的例子中，Shape 类是一个抽象类，其中定义了一个抽象方法 draw()。Circle 类和 Square 类都是 Shape 类的子类，并且必须实现 draw() 方法。通过抽象类 Shape 的引用变量分别引用 Circle 对象和 Square 对象，实现了多态性。
这四种方式都可以实现多态性，并且使代码更加灵活、可扩展，提高了可读性和可维护性。
PS：方法重载仅在同一个类中有效，不能实现跨类的多态性，而继承和方法重写、接口实现可以实现跨类的多态性。
多态的优点
- 消除类型之间的耦合关系
- 可替换性
- 可扩充性
- 接口性
- 灵活性
- 简化性
结尾语：记录于2023年8月2号11时16分，以上仅为个人在Java多态—菜鸟教程的学习过程中遇到的问题，还有记录的个人想法，有错误欢迎指出，希望对您有帮助，感谢观看！如果可以的话，点点赞，点点关注
