本文深入探讨java中对象类型与引用类型在多态性中的交互。通过实例解析，阐明编译时类型与运行时类型的区别，解释向上转型后方法调用的规则，以及方法重写如何影响实际执行。文章强调了类型转换的必要性和@override注解的最佳实践，旨在提升对java面向对象特性的理解。
理解Java中的编译时类型与运行时类型
在Java编程中，当我们声明一个引用变量并为其赋值时，会涉及到两个核心概念：编译时类型（Compile-time Type）和运行时类型（Runtime Type）。编译时类型是指声明变量时所使用的类型，而运行时类型则是该引用实际指向的对象的类型。理解这两者之间的区别是掌握Java多态性的基础。
考虑以下类结构及示例代码：
// 父类：Bicycle
public class Bicycle {
public int cadence;
public int gear;
public int speed;
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
public void printDescription(){
System.out.println("\nBike is " + "in gear " + this.gear
+ " with a cadence of " + this.cadence +
" and travelling at a speed of " + this.speed + ". ");
}
}// 子类：MountainBike，继承自Bicycle
public class MountainBike extends Bicycle {
private String suspension;
public MountainBike(
int startCadence,
int startSpeed,
int startGear,
String suspensionType){
super(startCadence,
startSpeed,
startGear);
this.setSuspension(suspensionType);
}
public void setSuspension(String suspensionType) {
this.suspension = suspensionType;
}
// 重写父类的printDescription方法
@Override
public void printDescription() {
super.printDescription(); // 调用父类的printDescription方法
System.out.println("The " + "MountainBike has a" +
getSuspension() + " suspension.");
}
public String getSuspension() {
return suspension;
}
}// 主程序类：Main
public class Main {
public static void main(String args[]){
Object obj = new MountainBike(1,2,3,"soft"); // 向上转型
System.out.println(obj.getClass()); // 输出运行时类型
System.out.println(obj.getClass().getSimpleName());
}
}在Main类的main方法中，Object obj = new MountainBike(1,2,3,"soft"); 这行代码展示了向上转型（Upcasting）。
- obj的编译时类型是Object。这意味着在编译阶段，编译器会根据Object类来检查obj的合法操作。
- obj的运行时类型是MountainBike。尽管obj被声明为Object类型，但它实际指向的内存中存储的是一个MountainBike对象。obj.getClass()方法正是返回这个对象的实际运行时类型，因此会输出class MountainBike和MountainBike。
这表明，一个对象的实际类型并不会因为被赋值给一个父类引用而改变，它始终保持着创建时的具体类型。
立即学习“Java免费学习笔记（深入）”；
方法调用的限制与动态分派
理解了编译时类型和运行时类型后，我们就能深入解析方法调用的行为。
编译时限制：方法的可调用性
在Java中，一个引用变量能够调用哪些方法，是由其编译时类型决定的。如果尝试调用一个在编译时类型中不存在的方法，编译器将报错。
例如，如果在上述Main类的main方法中直接调用obj.printDescription()：
public class Main {
public static void main(String args[]){
Object obj = new MountainBike(1,2,3,"soft");
// obj.printDescription(); // 这行代码会引发编译错误
// 错误信息：Cannot resolve method 'printDescription' in 'Object'
}
}尽管obj的运行时类型是MountainBike，并且MountainBike类中确实有printDescription()方法，但由于obj的编译时类型是Object，而Object类中没有printDescription()方法，编译器会报错。这是因为编译器在编译阶段无法确定obj实际指向的对象类型，为了保证类型安全，它只允许调用Object类型中定义的方法。
运行时动态分派：方法的实际执行
然而，当一个方法被成功调用时（即该方法在编译时类型中存在），实际执行哪个方法版本，则是由对象的运行时类型决定的，这称为动态方法分派（Dynamic Method Dispatch）。如果子类重写了父类的方法，那么在运行时将调用实际对象类型（运行时类型）中重写的方法。
继续看Main类的示例：
public class Main {
public static void main(String args[]){
Object obj = new MountainBike(1,2,3,"soft");
((Bicycle) obj).printDescription(); // 显式向下转型为Bicycle
}
}在这里，obj首先被强制类型转换为Bicycle类型。此时，表达式((Bicycle) obj)的编译时类型变成了Bicycle。因为Bicycle类中声明了printDescription()方法，所以编译器允许这个调用。
在运行时，尽管引用变量的编译时类型是Bicycle，但由于obj实际指向的是一个MountainBike对象，并且MountainBike类重写了printDescription()方法，Java的动态分派机制会确保调用MountainBike类中的printDescription()方法。这就是为什么控制台输出结果会包含“The MountainBike has a soft suspension.”，而不是仅仅Bicycle的描述。
Console Result: class MountainBike MountainBike Bike is in gear 3 with a cadence of 1 and travelling at a speed of 2. The MountainBike has asoft suspension.
类型转换与方法重写最佳实践
类型转换
- 向上转型（Upcasting）： 将子类对象赋值给父类引用变量。这是隐式且安全的，因为它总是有效的（子类“是”父类的一种）。例如：Bicycle bike = new MountainBike(...);。向上转型后，通过父类引用只能访问父类中声明的方法和字段。
- 向下转型（Downcasting）： 将父类引用变量强制转换为子类类型。这是显式的操作，并且存在风险。如果实际对象不是目标子类类型，将抛出ClassCastException。向下转型通常用于访问子类特有的方法或字段。在进行向下转型前，可以使用instanceof关键字进行类型检查，以避免运行时错误。
方法重写（Method Overriding）
当子类需要提供父类某个方法的特定实现时，就进行方法重写。重写方法必须与父类方法有相同的名称、参数列表和返回类型（或其子类型）。
@Override 注解
在重写父类方法时，强烈建议使用@@Override注解。
public class MountainBike extends Bicycle {
// ...
@Override // 明确表示这是一个重写方法
public void printDescription() {
super.printDescription(); // 调用父类的实现
System.out.println("The " + "MountainBike has a" +
getSuspension() + " suspension.");
}
// ...
}@Override注解本身并不会改变方法的行为，但它具有以下重要作用：
- 编译时检查： 如果被注解的方法没有正确地重写父类或接口的方法（例如，方法签名不匹配），编译器会报错，从而避免潜在的运行时错误。
- 提高可读性： 明确告知阅读代码的人，这个方法是重写父类或接口中的方法，增强了代码的清晰度和可维护性。
总结与注意事项
- 核心原则： 编译时类型决定方法的可调用性，运行时类型决定方法的实际执行（通过动态分派）。这是理解Java多态性的关键。
- 对象特性： 当一个子类对象被向上转型为父类引用时，它不会失去子类的任何特性，只是通过父类引用暂时无法直接访问这些特性。
- 类型转换： 要访问向上转型后子类特有的方法或字段，需要进行向下转型。在进行向下转型时，务必确保对象的实际类型与目标类型兼容，否则会导致ClassCastException。
- 最佳实践： 始终在重写方法时使用@Override注解，以确保代码的正确性和可读性。
- 持续学习： 深入理解这些面向对象编程（OOP）的基本概念是掌握Java的关键。建议通过实践，例如开发小型项目，来巩固这些知识，并查阅官方文档或权威教程以获取更全面的信息。
