java 多态通过向上转型调用,即把子类对象赋值给父类引用变量,利用动态绑定在运行时根据实际对象类型执行对应方法。具体做法是定义包含抽象或虚方法的父类及实现该方法的子类,实例化子类并赋给父类变量后直接调用方法,jvm 会自动查找并执行子类中重写的逻辑。

如何声明和初始化向上转型的父类引用
向上转型的核心在于声明一个父类类型的变量,并将子类实例赋值给它。这要求子类必须继承自该父类,且赋值过程是隐式的、安全的。例如,创建一个 Animal 类的引用指向 Dog 类的对象,编译器只认得 Animal 的方法签名,但运行时会识别出实际的 Dog 实例。

public class Animal {
public void speak() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void speak() {
System.out.println("Woof!");
}
}
public class Main {
public static void main(String[] args) {
// 向上转型:子类对象赋给父类引用
Animal myPet = new Dog();
myPet.speak(); // 输出: Woof!
}
}
上述代码中,myPet 被声明为 Animal 类型,但内存中实际存放的是 Dog 对象。当调用 speak() 时,由于 Dog 重写了该方法,程序会执行子类的版本。这种机制允许我们在不修改调用代码的情况下,通过替换不同的子类对象来改变行为,实现了开闭原则。
立即学习“Java免费学习笔记(深入)”;
使用 Husky 将 pre-commit、pre-push 和 commit-msg 检查集成到仓库中,以便代理和开发人员在更改离开工作站之前运行相同的本地防护措施。
向上转型后能访问哪些成员和方法
向上转型后,引用变量只能访问父类中定义的成员,包括方法和字段。如果子类定义了父类中没有的新方法,或者重写了父类的方法,只有重写的方法可以通过父类引用调用,而新增的方法无法直接访问。此外,静态方法和静态字段属于类而非实例,因此不会发生多态,始终调用父类的版本。

public class Parent {
int x = 10;
public void show() {
System.out.println("Parent show");
}
public static void staticShow() {
System.out.println("Parent static");
}
}
public class Child extends Parent {
int x = 20;
@Override
public void show() {
System.out.println("Child show");
}
public void newMethod() {
System.out.println("New method");
}
}
public class Main {
public static void main(String[] args) {
Parent p = new Child();
p.show(); // 输出: Child show (多态)
p.staticShow(); // 输出: Parent static (无多态)
// p.newMethod(); // 编译错误:Parent 引用不能访问 Child 特有方法
System.out.println(p.x); // 输出: 10 (字段无多态,看引用类型)
}
}
在这个例子中,p.show() 调用了子类的实现,体现了多态性。然而,p.staticShow() 和 p.x 都遵循了编译期绑定的规则,分别输出了父类的静态方法和字段值。这意味着向上转型限制了开发者对子类特有功能的直接访问,如果需要调用子类新增的方法,必须进行向下转型(强制类型转换)。
向上转型时如何处理子类特有的方法调用
当需要通过父类引用调用子类特有的方法时,必须进行向下转型。这通常发生在我们需要将通用处理后的对象还原为具体类型以执行特定操作时。使用 instanceof 关键字进行类型检查可以确保转型的安全性,避免抛出 ClassCastException。只有在确认对象确实是目标子类实例后,才能安全地将其转换为子类引用并调用其特有方法。
public class Main {
public static void main(String[] args) {
Animal myPet = new Dog();
// 尝试直接调用特有方法会导致编译错误
// myPet.bark();
// 正确的做法:先检查类型,再向下转型
if (myPet instanceof Dog) {
Dog d = (Dog) myPet;
d.bark(); // 假设 Dog 类有 bark() 方法
}
}
}
这种模式在处理集合中的多态对象时非常常见。例如,一个存储 Animal 对象的列表中可能包含 Dog、Cat 等不同子类。遍历列表时,我们可以统一调用 speak(),但在需要执行特定于狗的行为(如 bark())时,必须先通过 instanceof 判断并向下转型。这种方式既保留了多态带来的灵活性,又能在必要时获取子类的特定功能。

















