核心概念回顾
在深入分析具体案例之前，我们首先回顾几个java中的核心概念：
向上转型 (Upcasting) 向上转型是指将子类对象赋值给父类引用变量的行为。例如，A a = new B(); 中，B 是 A 的子类。此时，引用变量 a 的编译时类型 (Compile-time Type) 是 A，而它实际指向的对象的运行时类型 (Runtime Type) 是 B。向上转型是多态性的基础，它允许我们通过父类接口来操作子类对象。
-
方法重载 (Method Overloading) 与 方法覆盖 (Method Overriding)
- 方法重载 (Overloading)：发生在同一个类中（或继承关系中，子类可以重载父类的方法），方法名相同但参数列表（参数类型、参数数量或参数顺序）不同。方法重载是编译时多态的一种体现，编译器在编译阶段根据参数类型和数量来决定调用哪个方法。
- 方法覆盖 (Overriding)：发生在继承关系中，子类实现了父类中已经定义的方法，并且方法签名（方法名、参数列表和返回类型）完全一致。方法覆盖是运行时多态（动态绑定）的一种体现，JVM在运行时根据对象的实际类型来决定调用哪个方法。
可变参数 (Varargs) 可变参数（...）是Java 5引入的特性，允许方法接受不定数量的同类型参数。例如，public void foo(String... s) 意味着 foo 方法可以接受零个或多个 String 类型的参数。在方法内部，可变参数被当作一个数组来处理。在方法重载解析中，可变参数方法的优先级低于固定参数列表的方法。
案例分析：向上转型与可变参数的交互
考虑以下Java代码示例：
public class Test {
public static void main(String[] args) {
A a = new B(); // 向上转型
a.foo("123"); // 调用方法
}
}
class A {
public void foo(String... s) {
System.out.println("A");
}
}
class B extends A {
public void foo(String s) {
System.out.println("B");
}
}当我们运行 Test 类时，输出结果是 A。这可能与一些开发者的直觉不符，因为 B 类中存在一个 foo(String s) 方法，看起来它更匹配 a.foo("123") 的调用。那么，为什么会调用 A 类中的 foo(String... s) 方法呢？
编译时方法解析过程
问题的关键在于方法重载的解析发生在编译时，并且是基于引用变量的编译时类型。
立即学习“Java免费学习笔记（深入）”；
A a = new B(); 这里发生了向上转型。变量 a 的编译时类型是 A，而其运行时类型是 B。
-
a.foo("123"); 当编译器看到这行代码时，它会执行以下步骤来解析方法调用：
- 确定引用变量的编译时类型： 编译器知道 a 的类型是 A。
- 在编译时类型 A 中查找匹配的方法： 编译器会在 A 类及其父类中查找名为 foo 且参数列表能匹配 "123"（一个 String 类型参数）的方法。
- A 类中可见的方法： A 类只定义了一个方法：public void foo(String... s)。
- 方法匹配： foo(String... s) 可以接受一个 String 参数（它会将 "123" 包装成一个 String[] 数组）。因此，编译器认为 A 类中的 foo(String... s) 是一个合法的匹配。
- 确定调用方法： 由于在 A 的接口中，这是唯一一个名为 foo 且能接受 String 参数的方法，编译器在编译时就将 a.foo("123") 绑定到了 A 类的 foo(String... s) 方法。
运行时执行： 尽管 a 实际指向的是一个 B 类型的对象，但由于方法重载的决策已经在编译时完成，并且绑定的目标是 A 类的 foo(String... s)。在运行时，JVM会检查 B 类是否覆盖了 A 类的 foo(String... s) 方法。在这个例子中，B 类并没有覆盖 foo(String... s)，而是定义了一个新的重载方法 foo(String s)。因此，最终执行的是 A 类中的 foo(String... s) 方法。
为何子类方法 B.foo(String s) 未被调用？
B 类中的 public void foo(String s) 方法是一个重载方法，而不是 A 类中 foo(String... s) 的覆盖方法。它的方法签名与父类的方法不同。当引用变量 a 的编译时类型是 A 时，编译器只能“看到” A 类中定义或继承的方法。B 类中特有的 foo(String s) 方法对于类型为 A 的引用变量是不可见的，除非将 a 强制转换为 B 类型。
如果我们将代码修改为：
public class Test {
public static void main(String[] args) {
B b = new B(); // 不进行向上转型
b.foo("123"); // 调用方法
}
}
class A {
public void foo(String... s) {
System.out.println("A");
}
}
class B extends A {
public void foo(String s) {
System.out.println("B");
}
}此时，输出结果将是 B。这是因为变量 b 的编译时类型是 B。编译器在 B 类中查找 foo("123") 时，会发现两个潜在的匹配：
- B 类自身定义的 public void foo(String s)
- 从 A 类继承的 public void foo(String... s)
在方法重载解析规则中，固定参数列表的方法（如 foo(String s)）比可变参数方法（如 foo(String... s)）具有更高的优先级。因此，编译器会选择 B 类中的 foo(String s) 方法。
总结与注意事项
- 重载是编译时决策： 方法重载的解析完全依赖于引用变量的编译时类型。编译器根据这个类型及其可见的方法签名来选择最匹配的方法。
- 覆盖是运行时决策： 方法覆盖（多态）则是在运行时根据对象的实际类型来决定。
- 可变参数的优先级： 在方法重载解析中，可变参数方法的优先级低于具有相同数量和类型参数的固定参数方法。
- 避免混淆： 在继承体系中，尽量避免创建父类使用可变参数方法，而子类使用固定参数方法（或反之）的重载组合，这极易导致混淆和难以预测的行为。
- 清晰的方法设计： 始终以清晰和可预测的方式设计方法签名，特别是在涉及继承和多态的场景中。如果需要子类提供不同的行为，优先考虑方法覆盖，而不是创建可能引起歧义的重载。
通过深入理解Java的编译时绑定和运行时绑定机制，以及方法重载与可变参数的优先级规则，开发者可以更好地预测代码行为，并避免在复杂的继承结构中引入潜在的错误。
