Java多态详解
多态（Polymorphism）是面向对象编程中的一个核心概念，意指"多种形态"。在Java中，多态允许我们以统一的方式处理不同类的对象，只要它们共享相同的父类或接口。简单来说，就是同一个行为，被不同的对象执行时，会展现出不同的结果。
多态的实现条件
要实现多态，需要满足以下三个条件：
- 继承关系： 必须存在父子类继承关系，或者类实现接口。
- 方法重写： 子类必须重写（Override）父类中已有的方法。
- 父类引用指向子类对象： 通过父类类型的引用变量来引用子类对象，并调用被重写的方法。
当使用父类引用调用被重写的方法时，实际执行的是子类中该方法的具体实现。这就是运行时多态（动态绑定）。
代码示例
package com.example.polymorphism;
// 父类
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void makeSound() {
System.out.println(name + " 发出动物的叫声");
}
}
// 子类 Cat
class Cat extends Animal {
public Cat(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + " 喵喵叫");
}
}
// 子类 Dog
class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + " 汪汪叫");
}
}
// 测试类
public class PolymorphismDemo {
public static void performAction(Animal animal) {
// 这里会根据运行时 animal 实际引用的对象类型来调用对应的方法
animal.makeSound();
}
public static void main(String[] args) {
Cat whiskers = new Cat("Whiskers");
Dog buddy = new Dog("Buddy");
performAction(whiskers); // 输出: Whiskers 喵喵叫
performAction(buddy); // 输出: Buddy 汪汪叫
}
}
重写 (Override) vs. 重载 (Overload)
- 重写： 发生在子类和父类之间，子类重新实现父类中的方法，方法名、参数列表和返回类型（或其子类型）必须与父类一致。这是实现多态的关键。
- 重载： 发生在同一个类中，允许定义多个同名方法，但它们的参数列表必须不同（参数类型、数量或顺序）。重载是在编译时确定的（静态绑定）。
向上转型 (Upcasting)
向上转型是指将子类对象赋值给父类类型的引用变量。这种转换是自动的，并且是安全的，因为它不会丢失任何信息。在向上转型后，我们只能访问父类中定义的成员（包括被重写的方法）。
// 假设有上面的 Animal, Cat, Dog 类
Animal myAnimal = new Cat("Mittens"); // 向上转型，Cat 对象被赋值给 Animal 引用
myAnimal.makeSound(); // 调用的是 Cat 的 makeSound() 方法 (输出: Mittens 喵喵叫)
// myAnimal.meow(); // 错误！Cat 类特有的 meow() 方法不能通过 Animal 引用调用
向上转型的主要优点在于提高代码的灵活性和可扩展性。例如，一个接收 `Animal` 类型参数的方法，可以接受任何 `Animal` 的子类对象，而无需修改方法本身。
向下转型 (Downcasting)
向下转型是指将父类类型的引用强制转换为子类类型的引用。这种转换不是自动的，需要显式声明，并且存在风险。如果父类引用实际指向的对象不是目标子类类型，则在运行时会抛出 `ClassCastException`。
为了提高向下转型的安全性，通常会结合使用 `instanceof` 运算符进行类型检查。
// 假设有上面的 Animal, Cat, Dog 类
Animal myAnimal = new Cat("Mittens");
if (myAnimal instanceof Cat) {
Cat specificCat = (Cat) myAnimal; // 向下转型
specificCat.makeSound(); // 可以调用 Cat 的方法
// specificCat.meow(); // 如果 Cat 有 meow() 方法，也可以调用
} else if (myAnimal instanceof Dog) {
Dog specificDog = (Dog) myAnimal;
specificDog.makeSound();
}
多态的优点
- 代码的灵活性和可扩展性： 允许在不修改现有代码的情况下添加新的子类。
- 代码的简洁性： 能够用统一的接口处理不同的对象，减少重复代码。
- 提高代码的可维护性： 将具体实现与接口分离，使得代码更容易理解和修改。
多态的缺点
- 运行效率略有降低： 由于需要进行运行时类型检查和方法查找（动态绑定），相比静态绑定，效率会有轻微下降。
- 属性不具备多态性： 成员变量（属性）不具备多态性。通过父类引用访问的永远是父类定义的属性。
- 构造方法不具备多态性： 在构造方法中调用实例方法时，如果该方法被子类重写，可能会因为子类实例尚未完全初始化而导致意外行为。因此，在构造方法中应尽量避免调用可能被子类重写的实例方法（除非这些方法是 `final` 或 `private` 的）。
构造方法中的方法调用示例
package com.example.polymorphism;
class Parent {
public Parent() {
// 调用实例方法
display();
}
public void display() {
System.out.println("Parent's display");
}
}
class Child extends Parent {
private int value = 10;
@Override
public void display() {
// 此时 Child 对象尚未完全构造，value 处于默认值（0 for int）
System.out.println("Child's display, value = " + value);
}
public static void main(String[] args) {
// 创建 Child 对象时，会先调用 Parent 的构造器
// Parent 构造器中调用 display()，由于动态绑定，实际执行 Child 的 display()
// 但此时 Child 的 value 变量还未初始化，所以输出 value = 0
Child child = new Child();
}
}
输出结果:
Child's display, value = 0
这说明在父类构造器中调用被子类重写的方法时，如果该方法访问了子类尚未初始化的成员变量，可能会出现问题。因此，应谨慎在构造方法中调用实例方法。
