Java 中多态中方法重载和多态怎么区分
方法重载（overload）和多态（polymorphism，此处主要指运行时多态/动态绑定）的核心区别在于决定调用哪个方法的时机不同：重载在编译期根据参数类型确定，属于静态绑定；而多态在运行期根据对象实际类型确定，属于动态绑定。简单来说，重载是“看参数”，多态是“看对象”。要区分它们，只需观察编译器能否仅凭代码中的声明类型就锁定具体的方法实现，如果能锁定就是重载，如果必须等到程序运行、实例化对象后才能确定，就是多态。
重载的判定依据与静态绑定机制
重载是指同一个类中或者父子类之间，存在多个同名但参数列表不同的方法。编译器在处理重载时，会严格检查方法签名（方法名+参数类型），并在编译阶段生成指向特定方法的字节码指令。这意味着，即使你使用父类引用指向子类对象，只要调用的方法是重载版本，编译器依然会根据引用的声明类型来选择方法，而不是对象的实际类型。
public class Animal {
public void eat() {
System.out.println("Animal eating");
}
public void eat(String food) {
System.out.println("Animal eating " + food);
}
}
public class Dog extends Animal {
// 重载了父类的 eat 方法，增加了参数
@Override
public void eat() {
System.out.println("Dog eating bone");
}
// 这是新的重载方法，不是重写
public void eat(String food, int amount) {
System.out.println("Dog eating " + amount + " " + food);
}
}
public class Main {
public static void main(String[] args) {
Animal myPet = new Dog();
// 1. 调用无参 eat(): 动态绑定，执行 Dog 的方法
myPet.eat();
// 2. 调用带一个 String 参数的 eat(): 静态绑定，执行 Animal 的方法
// 因为 Dog 没有覆盖 eat(String)，且编译器只看 myPet 的类型 Animal
myPet.eat("meat");
}
}
在上述代码中，`myPet.eat()` 触发了多态，因为 `Dog` 重写了 `Animal` 的无参方法，JVM 会在运行时发现 `myPet` 实际指向 `Dog` 实例，从而调用 `Dog` 的实现。然而，`myPet.eat("meat")` 触发的是重载解析。虽然 `Dog` 继承了 `Animal` 的 `eat(String)` 方法，但这里并没有发生重写（Override），而是作为继承来的方法被调用。更关键的是，如果我们定义了一个只在 `Dog` 中存在的新重载方法 `eat(String, int)`，通过 `Animal` 引用是无法调用的，这证明了重载的判定完全依赖于编译期的类型检查。
立即学习“Java免费学习笔记（深入）”；
多态的运行机制与动态绑定条件
多态（动态绑定）要求方法在子类中被重写（Override），且调用时必须通过父类或接口的引用来操作子类的实例。只有满足这三个条件：继承关系、方法重写、父类引用指向子类对象，JVM 才会启动动态分派机制。在运行期，JVM 会查看对象内存中的实际类型表，找到对应的方法实现。这与重载形成鲜明对比，重载不涉及对象类型的切换，只涉及参数匹配。
public interface Shape {
double area();
}
public class Circle implements Shape {
private double radius;
public Circle(double r) { this.radius = r; }
@Override
public double area() {
return Math.PI * radius * radius;
}
}
public class Square implements Shape {
private double side;
public Square(double s) { this.side = s; }
@Override
public double area() {
return side * side;
}
}
public class Main {
public static void main(String[] args) {
Shape s1 = new Circle(5.0);
Shape s2 = new Square(4.0);
// 多态调用：编译期知道是 Shape.area()，运行期决定具体执行谁
System.out.println(s1.area()); // 输出 Circle 的计算结果
System.out.println(s2.area()); // 输出 Square 的计算结果
}
}
在这个例子中，`s1` 和 `s2` 的编译时类型都是 `Shape`，因此编译器只允许调用 `Shape` 接口中声明的 `area()` 方法。但是，当程序真正运行时，JVM 检测到 `s1` 背后是一个 `Circle` 对象，于是调用 `Circle` 的 `area()` 实现；检测到 `s2` 背后是 `Square` 对象，则调用 `Square` 的实现。这种“同一种接口，多种表现”的行为就是多态。它不关心参数列表的变化，只关心对象本身的类型身份。如果我们将 `area()` 改为带参数的 `area(double factor)`，且在 `Circle` 和 `Square` 中都进行了重写，那么上述的多态行为依然成立，这正是多态灵活性的体现。
当子类同时存在重载和重写时的冲突处理
在实际开发中，经常会出现子类既重写了父类方法，又新增了重载方法的情况。此时，通过父类引用访问这些方法时，最容易产生混淆。核心规则是：父类引用只能访问父类中声明过的方法（包括被重写的），无法直接访问子类新增的重载方法。如果子类想暴露这些新增的重载方法，必须将引用类型强转为子类类型。
public class Base {
public void process(int x) {
System.out.println("Base: " + x);
}
}
public class Sub extends Base {
// 重写父类方法
@Override
public void process(int x) {
System.out.println("Sub (override): " + x);
}
// 新增重载方法
public void process(String s) {
System.out.println("Sub (overload): " + s);
}
}
public class Main {
public static void main(String[] args) {
Base b = new Sub();
// 1. 多态调用：执行 Sub 的重写版本
b.process(10);
// 2. 编译错误！Base 类中没有 process(String) 方法
// b.process("hello");
// 3. 正确做法：强转回 Sub 类型以访问重载方法
((Sub) b).process("hello");
}
}
这段代码清晰地展示了界限：`b.process(10)` 是多态，因为 `Base` 中有该方法且 `Sub` 重写了它，JVM 动态选择了 `Sub` 的实现。而 `b.process("hello")` 会导致编译失败，因为编译器在检查 `Base` 类时，根本找不到接受 `String` 参数的方法，尽管实际的 `Sub` 对象里有这个方法。这说明重载方法的可见性受限于引用类型的声明，而多态行为的生效则完全取决于对象的实际类型。要调用子类特有的重载方法，必须打破多态的引用限制，进行显式转型。
