行为的多形态表现
在Java面向对象编程中,多态（Polymorphism）是指“同一操作作用于不同的对象时，会产生不同的执行结果”，多态允许我们用统一的接口调用不同类的实现方法，从而实现“同一行为，多种形态”的特性，假设有一个“动物”类，它有一个“叫声”的方法，当这个方法被“猫”或“狗”对象调用时，会分别输出“喵喵”和“汪汪”，这就是多态的直观体现，多态是面向对象编程的三大特性之一（封装、继承、多态），它让代码更具扩展性和灵活性，能够降低模块间的耦合度。
实现多态的三大必要条件
要实现Java中的多态,必须同时满足以下三个条件，缺一不可：
- 继承关系：必须有类之间的继承，子类继承父类（或接口实现接口），这是多态的基础，因为子类会继承父类的属性和方法，为后续的重写和统一调用提供前提。
- 方法重写：子类必须重写父类的非静态、非私有、非final方法，重写是指子类保留父类方法名、参数列表和返回值类型（或协变返回类型），但重新实现方法的具体逻辑，这样，当父类引用指向子类对象时，实际调用的是子类重写后的方法。
- 父类引用指向子类对象：在创建对象时，需要使用父类的类型作为引用类型，指向子类的实例，这是多态的核心语法，称为“向上转型”（Upcasting），通过这种方式，可以用统一的父类引用调用不同子类的重写方法。
代码实现：从继承到多态的完整步骤
下面通过一个具体的例子,逐步展示如何通过代码实现多态，假设场景：有一个“图形”（Shape）父类，它有一个“绘制”（draw）方法，子类“圆形”（Circle）和“矩形”（Rectangle）继承Shape并重写draw方法，最终通过父类引用调用不同子类的绘制逻辑。
定义父类Shape
定义一个抽象父类Shape（也可以是普通类，但抽象类更符合“抽象行为”的设计），Shape类中声明一个抽象方法draw（抽象方法没有方法体，强制子类必须重写）：
// 抽象父类：图形
public abstract class Shape {
// 抽象方法：绘制图形（子类必须重写）
public abstract void draw();
// 普通方法：描述图形（子类可直接继承，也可重写）
public void describe() {
System.out.println("这是一个图形");
}
}
定义子类并重写方法
创建Shape的子类Circle和Rectangle,分别重写draw方法，实现各自的绘制逻辑：
// 子类：圆形
public class Circle extends Shape {
@Override
public void draw() {
System.out.println("绘制一个圆形：○");
}
// 子类可扩展自己的方法
public void calculateArea() {
System.out.println("计算圆形面积");
}
}
// 子类：矩形
public class Rectangle extends Shape {
@Override
public void draw() {
System.out.println("绘制一个矩形：□");
}
// 子类可扩展自己的方法
public void calculatePerimeter() {
System.out.println("计算矩形周长");
}
}
创建父类引用指向子类对象（向上转型）
在测试类中,使用Shape类型的引用指向Circle和Rectangle的实例，这就是“向上转型”，通过父类引用调用draw方法，此时会根据实际指向的子类对象，调用对应的重写方法：
public class PolymorphismDemo {
public static void main(String[] args) {
// 1. 父类引用指向子类对象（向上转型）
Shape circleShape = new Circle();
Shape rectangleShape = new Rectangle();
// 2. 通过父类引用调用重写的方法（多态体现）
circleShape.draw(); // 输出：绘制一个圆形：○
rectangleShape.draw(); // 输出：绘制一个矩形：□
// 3. 调用父类的普通方法（子类继承，无需重写）
circleShape.describe(); // 输出：这是一个图形
rectangleShape.describe(); // 输出：这是一个图形
// 4. 注意：父类引用无法直接调用子类特有的方法
// circleShape.calculateArea(); // 编译错误：Shape类中没有calculateArea方法
}
}
向下转型：调用子类特有方法
如果需要通过父类引用调用子类的特有方法（如Circle的calculateArea），需要先进行“向下转型”（Downcasting），即把父类引用强制转换为子类类型，但需要注意，向下转型前必须先用instanceof关键字检查类型，避免ClassCastException异常：
public class PolymorphismDemo {
public static void main(String[] args) {
Shape shape = new Circle(); // 向上转型
// 1. 先用instanceof检查类型，再向下转型
if (shape instanceof Circle) {
Circle circle = (Circle) shape; // 向下转型
circle.calculateArea(); // 输出：计算圆形面积
}
// 2. 错误示例：未检查类型直接转型
// Rectangle rect = (Rectangle) shape; // 运行时抛出ClassCastException
}
}
抽象类与接口：多态的扩展实现
除了通过继承实现多态,Java还支持通过接口实现多态，接口（Interface）是一组方法的抽象集合，类通过实现接口来提供具体的逻辑，接口多态的实现方式与继承类似：接口引用指向实现类对象，调用接口定义的方法。
定义接口和实现类
假设有一个“飞行器”（Flyable）接口，定义了“飞行”（fly）方法，飞机”（Airplane）和“鸟”（Bird）类实现该接口：
// 接口：飞行器
public interface Flyable {
void fly(); // 接口方法默认为public abstract
}
// 实现类1：飞机
public class Airplane implements Flyable {
@Override
public void fly() {
System.out.println("飞机通过引擎飞行");
}
}
// 实现类2：鸟
public class Bird implements Flyable {
@Override
public void fly() {
System.out.println("鸟通过翅膀飞行");
}
}
接口多态的调用
通过Flyable接口引用指向Airplane和Bird对象,调用fly方法，体现多态：
public class InterfacePolymorphismDemo {
public static void main(String[] args) {
Flyable airplane = new Airplane();
Flyable bird = new Bird();
// 接口多态：同一接口调用，不同实现
airplane.fly(); // 输出：飞机通过引擎飞行
bird.fly(); // 输出：鸟通过翅膀飞行
}
}
多态的核心优势：为什么需要多态
多态不是Java的“语法炫技”，而是解决实际编程问题的重要特性，其核心优势体现在以下三方面：
- 扩展性（开闭原则）：当需要新增功能时，只需新增子类或实现类，无需修改现有代码，在Shape的例子中，若需新增“三角形”（Triangle）类，只需继承Shape并重写draw方法，无需修改PolymorphismDemo中的调用逻辑。
- 代码复用性：通过父类或接口统一管理对象，避免重复编写相似代码，可以用一个方法接收Shape类型的参数，统一处理所有图形对象：
public static void drawShape(Shape shape) { shape.draw(); // 无论传入Circle还是Rectangle，都能正确绘制 } - 可维护性：降低模块间的耦合度，调用方只需依赖父类或接口，无需关心具体的子类实现，当子类逻辑变化时，调用方代码无需修改。
使用多态时的注意事项
虽然多态强大,但使用时需注意以下“陷阱”，避免常见错误：
- 成员变量没有多态性：多态仅针对方法，成员变量在父类引用中访问的是父类自身的变量。
class Parent { int value = 10; } class Child extends Parent { int value = 20; } public class Test { public static void main(String[] args) { Parent parent = new Child(); System.out.println(parent.value); // 输出：10（访问父类value） } } - 静态方法没有多态性：静态方法属于类，不属于对象，因此父类引用调用静态方法时，始终执行父类的方法，与实际指向的子类对象无关。
- final方法无法重写：被final修饰的方法不能被重写，因此无法通过多态调用子类逻辑。
- 避免向下转型的类型错误：向下转型前务必用instanceof检查类型，否则可能抛出ClassCastException。
Java多态的实现依赖于继承/接口、方法重写和父类引用指向子类对象这三个核心要素，通过多态，我们可以编写出更灵活、可扩展、易维护的代码，充分体现面向对象编程的优势，掌握多态，是从“会用Java”到“用好Java”的重要一步。
