1. 当父类与子类方法“撞名”一个看似简单却暗藏玄机的起点在面向对象编程的世界里继承是构建复杂、可复用代码体系的基石。它允许我们基于已有的类父类创建新的类子类子类自动获得父类的属性和方法这听起来既优雅又强大。然而当子类中定义了一个与父类同名同参数的方法时一个看似简单的问题就浮出水面程序运行时到底会调用谁这个问题就是方法重写Override的核心。几乎所有面向对象的语言如Java、C、Python、C#、JavaScript等都遵循一个基本规则子类对象调用重名方法时优先调用子类自己的版本。这个规则是动态绑定或多态性的基础。但“优先”二字背后远不止一个简单的结论。它涉及到编译时与运行时的区别、访问权限的影响、静态方法的特殊性以及在复杂继承链中方法解析的路径。很多开发者尤其是初学者往往在遇到一些“反直觉”的情况时才会意识到自己对这条规则的理解可能还不够深入。比如一个Animal类有个makeSound()方法输出“Some generic animal sound”它的子类Dog重写了这个方法输出“Woof!”。当我们用Dog dog new Dog(); dog.makeSound();时输出“Woof!”毫无悬念。但如果引用类型是父类呢Animal myPet new Dog(); myPet.makeSound();结果是什么这就是多态的经典体现答案依然是“Woof!”。因为实际的对象类型Dog决定了调用哪个方法。然而故事并没有结束。如果方法是private的、static的、或者final的呢如果子类只是“重载”而非“重写”呢在多重继承如C或通过原型链实现的继承如JavaScript中查找顺序又是怎样的这些细节才是真正区分“知道”和“理解”的关键。本文将从一个资深开发者的视角不仅厘清方法调用的基本优先级更深入那些容易混淆的边界情况和底层原理让你下次遇到类似问题时能够胸有成竹一眼看穿本质。2. 重写Override的本质动态绑定的胜利要理解优先级必须先彻底搞懂什么是真正的方法重写。重写不是简单的名字相同它有一系列严格的契约。2.1 构成有效重写的严格条件在Java这类强类型语言中方法重写必须满足以下所有条件缺一不可方法名完全相同。参数列表完全相同参数的类型、数量、顺序。即使参数名不同也没用。返回类型兼容在Java 5之前要求返回类型必须完全相同。从Java 5开始引入了协变返回类型允许子类重写方法的返回类型是父类方法返回类型的子类。访问权限不能更严格子类重写方法的访问修饰符public, protected, default不能比父类被重写方法的访问修饰符更严格。例如父类方法是protected子类可以重写为public或protected但不能重写为default或private。不能重写final方法被final修饰的方法无法被重写。不能重写static方法静态方法属于类不属于对象实例因此不存在“重写”只有“隐藏”。异常声明子类重写方法声明的异常范围不能大于父类方法声明的异常范围即子类异常可以是父类异常的子集或者不抛出检查型异常。只有同时满足这些条件编译器才会认为这是一个有效的重写。此时子类方法完全覆盖了父类方法的实现。在运行时JVM以Java为例通过对象实际类型的方法表进行动态查找永远调用实际对象类型子类中的版本。这就是“动态绑定”或“后期绑定”。class Animal { public void makeSound() { System.out.println(Some generic animal sound); } } class Dog extends Animal { Override // 使用Override注解是良好习惯编译器会帮你检查重写是否符合规则 public void makeSound() { // 方法名、参数列表、返回类型、访问权限均符合重写规则 System.out.println(Woof!); } } public class Test { public static void main(String[] args) { Animal myPet new Dog(); // 编译时类型是Animal运行时类型是Dog myPet.makeSound(); // 输出: Woof! 运行时根据实际对象类型(Dog)决定调用哪个方法 } }注意Override注解在Java中不是必须的但强烈建议使用。它可以让编译器在编译期就帮你检查该方法是否真的成功重写了父类方法避免因拼写错误或签名不匹配而导致的“自以为重写”的bug。2.2 “编译看左边运行看右边”的深度解析“编译看左边运行看右边”这句口诀是对多态下方法调用优先级的一个精炼总结但需要正确理解。编译看左边编译器在编译阶段只认引用变量声明时的类型即左边。它根据这个类型来检查你调用的方法是否存在、访问权限是否允许。如果父类引用左边的类型中没有这个方法或者该方法不可见如private编译就会报错。运行看右边到了运行阶段JVM不再关心引用变量的类型而是根据实际创建的对象的类型即new关键字后面的类型右边来决定调用哪个方法实现。它会去实际对象所属类的方法表中查找。这个机制是实现“面向接口编程”和“开闭原则”的关键。我们可以编写依赖于父类或接口的通用代码而在运行时传入不同的子类对象来获得不同的行为无需修改原有代码。3. 优先级规则的例外与边界情况如果所有方法都遵循上述动态绑定那世界就简单了。但语言设计者为了灵活性、安全性或性能设定了一些例外这些地方恰恰是容易踩坑的。3.1 静态方法属于类的“隐藏”而非对象的重写静态方法与类绑定而非与对象实例绑定。因此静态方法不能被重写只能被隐藏。调用哪个静态方法取决于引用变量的编译时类型而不是运行时对象的实际类型。这失去了多态性。class Parent { public static void staticMethod() { System.out.println(Static in Parent); } } class Child extends Parent { public static void staticMethod() { // 这不是重写是隐藏 System.out.println(Static in Child); } } public class TestStatic { public static void main(String[] args) { Parent p new Child(); p.staticMethod(); // 输出: Static in Parent (看引用类型Parent) Child c new Child(); c.staticMethod(); // 输出: Static in Child (看引用类型Child) // 正确的调用静态方法的方式是通过类名 Parent.staticMethod(); // Static in Parent Child.staticMethod(); // Static in Child } }实操心得永远使用类名.静态方法名()的方式来调用静态方法这样可以避免因引用类型导致的混淆代码意图也更清晰。IDE通常也会给出警告提示。3.2 私有方法不可见的屏障私有方法private只在定义它的类内部可见。子类根本“看不到”父类的私有方法因此子类中定义一个与父类私有方法同名同参数的方法不构成重写而是子类的一个全新的方法。这两个方法在各自类的范围内独立存在。class Parent { private void privateMethod() { System.out.println(Private in Parent); } public void callPrivate() { privateMethod(); // 这里调用的永远是Parent自己的privateMethod } } class Child extends Parent { // 这不是重写只是Child自己的一个方法与Parent的privateMethod无关。 private void privateMethod() { System.out.println(Private in Child); } // 可以重写public方法 Override public void callPrivate() { // super.callPrivate(); // 如果调用父类方法里面还是执行Parent的privateMethod System.out.println(Childs callPrivate); privateMethod(); // 这里调用的是Child自己的privateMethod } } public class TestPrivate { public static void main(String[] args) { Parent p new Child(); p.callPrivate(); // 如果Child没重写callPrivate输出Private in Parent。 // 如果Child重写了callPrivate则执行Child的callPrivate输出Childs callPrivate和Private in Child。 } }由于私有方法不可被外部包括子类访问所以不存在子类对象通过父类引用调用到子类私有方法的情况。它的调用完全由定义它的类在编译期决定。3.3 Final方法终结的契约用final修饰的方法表示该方法的设计和实现是“最终版本”不允许任何子类对其进行修改重写。这通常用于确保关键算法、模板方法中的步骤不被篡改或者出于安全、性能的考虑。class SecurityBase { public final void criticalOperation() { // 执行一些关键的安全操作不希望子类改变 System.out.println(Performing critical security operation...); } } class SubClass extends SecurityBase { // 以下代码会导致编译错误 // Override // public void criticalOperation() { ... } }试图重写final方法会在编译期直接报错。因此final方法的调用优先级是确定且唯一的永远调用父类中定义的版本。3.4 构造方法特殊的初始化过程构造方法名必须与类名相同因此父子类的构造方法名天生不同不存在“重写”的概念。但存在调用链。子类构造方法的第一行如果没有显式写出编译器会自动插入对父类无参构造方法super()的调用。如果父类没有无参构造子类必须显式调用父类的有参构造。构造方法的调用顺序是从最顶层的父类向下直到当前子类。在构造方法中调用可重写的方法是危险的做法因为此时子类的字段可能还未初始化。4. 方法重载Overload与重写的混淆区重载发生在同一个类中或父子类之间其核心是方法名相同但参数列表不同。返回值不同不足以构成重载。当重载遇上继承调用哪个方法的判断逻辑与重写不同。4.1 父子类间的重载解析对于重载方法编译器在编译期就根据方法签名方法名参数列表和引用变量的编译时类型来确定调用哪一个。这是一个静态绑定的过程。class Printer { public void print(String s) { System.out.println(Printing String: s); } public void print(Integer i) { System.out.println(Printing Integer: i); } } class AdvancedPrinter extends Printer { // 重载了父类的print方法增加了一个新版本 public void print(Double d) { System.out.println(Printing Double: d); } // 这里也可以选择重写父类的某个print方法 Override public void print(String s) { System.out.println(Advanced Printing String: s); } } public class TestOverload { public static void main(String[] args) { Printer p new AdvancedPrinter(); p.print(Hello); // 输出: Advanced Printing String: Hello (动态绑定重写生效) p.print(100); // 输出: Printing Integer: 100 (静态绑定根据编译时类型Printer找到参数最匹配的print(Integer)) // p.print(3.14); // 编译错误编译时类型Printer没有print(Double)方法 AdvancedPrinter ap new AdvancedPrinter(); ap.print(3.14); // 输出: Printing Double: 3.14 (编译时类型AdvancedPrinter有自己的print(Double)) } }关键点在于重载看编译时类型重写看运行时类型。对于p.print(100)编译器看到p的类型是Printer于是在Printer类中寻找参数最匹配的print方法找到了print(Integer)。虽然运行时对象是AdvancedPrinter但AdvancedPrinter并没有重写print(Integer)所以执行的是父类Printer中的版本。4.2 避免重写与重载的意外交互一个常见的陷阱是自以为在重写实际上却在重载。class Base { public void process(Object obj) { System.out.println(Processing Object in Base); } } class Derived extends Base { // 小心这不是重写因为参数类型不同。这是重载 public void process(String str) { System.out.println(Processing String in Derived); } } public class TestTrap { public static void main(String[] args) { Base b new Derived(); Object o I am a String; b.process(o); // 输出: Processing Object in Base // 编译时b的类型是BaseBase中process(Object)是唯一匹配的。 // 运行时Derived没有重写process(Object)所以调用Base的版本。 // 尽管传入的实际上是一个String对象。 } }要避免这个坑务必使用Override注解。在上面的Derived类中如果你在process(String)前加上Override编译器会立即报错提示你并没有成功重写父类的任何方法因为它签名不匹配。这能帮你及早发现设计意图的错误。5. 复杂继承链与方法解析顺序在单继承语言如Java中方法查找是一条清晰的链从对象的实际类开始沿着继承树向上查找直到找到第一个匹配的方法签名。但在支持多重继承或类似机制的语言中情况更复杂。5.1 Java的单继承与接口默认方法Java类是单继承但可以实现多个接口。在Java 8之前接口中的方法都是抽象的不存在实现冲突。Java 8引入了默认方法default方法这使得一个类可能从多个接口继承到相同签名的方法实现从而产生冲突。冲突解决规则如下类优先如果一个类继承了父类的具体方法和接口的默认方法签名相同那么父类的方法获胜。接口的默认方法被忽略。接口冲突如果一个类实现了多个接口而这些接口包含了相同签名的默认方法那么这个类必须重写这个方法以消除二义性。在重写的方法中可以通过接口名.super.方法名()的语法来显式调用某个接口的默认实现。interface InterfaceA { default void doSomething() { System.out.println(Default implementation from InterfaceA); } } interface InterfaceB { default void doSomething() { System.out.println(Default implementation from InterfaceB); } } class ParentClass { public void doSomething() { System.out.println(Implementation from ParentClass); } } // 情况1类优先 class MyClass1 extends ParentClass implements InterfaceA { // 从ParentClass继承了doSomethingInterfaceA的默认方法被忽略。 // 调用new MyClass1().doSomething() 会输出 Implementation from ParentClass } // 情况2接口冲突必须重写 class MyClass2 implements InterfaceA, InterfaceB { Override public void doSomething() { // 必须重写否则编译错误 System.out.println(My own implementation); // 或者选择其中一个接口的默认实现 InterfaceA.super.doSomething(); // 调用InterfaceA的默认方法 } }5.2 C中的多重继承与虚函数C支持多重继承一个类可以有多个直接父类。当这些父类有相同签名的虚函数相当于可重写方法时如果子类没有重写就会产生二义性编译器不知道通过子类对象调用时该走哪条路径。必须通过**类名作用域解析运算符::**来显式指定。class Base1 { public: virtual void func() { cout Base1::func endl; } }; class Base2 { public: virtual void func() { cout Base2::func endl; } }; class Derived : public Base1, public Base2 { public: // 如果不重写func下面调用会报错对成员‘func’的请求不明确 // void func() override { cout Derived::func endl; } // 重写后调用自己的版本 }; int main() { Derived d; // d.func(); // 错误二义性 d.Base1::func(); // 正确显式调用Base1的版本 d.Base2::func(); // 正确显式调用Base2的版本 // 通过指针或引用需要类型转换来明确 Base1* b1Ptr d; b1Ptr-func(); // 输出取决于Derived是否重写。若重写输出Derived::func若未重写输出Base1::func。 Base2* b2Ptr d; b2Ptr-func(); // 同理。 }C通过虚函数表vtable来实现动态绑定每个有虚函数的类都有自己的虚函数表。在多重继承下子类对象可能包含多个父类子对象也就可能有多个虚函数表指针。方法调用时需要根据对象的静态类型进行适当的this指针偏移然后查找对应的虚函数表。这是C对象模型中比较复杂的一部分。5.3 Python中的方法解析顺序MROPython支持多继承。为了解决在菱形继承等场景下方法查找的顺序问题Python使用了C3线性化算法来计算一个类的方法解析顺序。你可以通过类名.__mro__属性来查看这个顺序。class A: def process(self): print(A.process) class B(A): def process(self): print(B.process) super().process() # 会调用MRO中的下一个类的process class C(A): def process(self): print(C.process) super().process() class D(B, C): def process(self): print(D.process) super().process() print(D.__mro__) # 输出: (class __main__.D, class __main__.B, class __main__.C, class __main__.A, class object) d D() d.process() # 输出: # D.process # B.process # C.process # A.processPython的super()是一个动态对象它并不是简单地调用“父类”而是按照__mro__列表的顺序去调用“下一个”类的方法。这种设计使得在协作式多继承中每个类都可以通过super()将调用传递给MRO链上的下一个类共同完成一个操作而无需知道具体的继承结构。6. 从原理到实践JVM中的方法调用与分派理解语言特性背后的实现机制能让我们对规则有更深刻的认识。以Java为例方法调用在JVM层面主要分为几种指令其优先级逻辑就蕴含其中。6.1 虚方法与非虚方法非虚方法在编译期就能确定具体调用版本的方法包括静态方法、私有方法、实例构造器、父类方法通过super调用以及被final修饰的方法。它们使用invokestatic调用静态方法、invokespecial调用构造器、私有方法、父类方法指令调用。虚方法其他所有方法即可以被重写的方法。它们使用invokevirtual大多数实例方法或invokeinterface调用接口方法指令调用。虚方法的调用目标需要在运行时根据接收者的实际类型来确定。6.2 方法表与动态查找每个类在加载后JVM会为其创建一个方法表这是一个数组存放了该类的所有方法的入口地址。子类的方法表会包含父类方法表的副本但如果子类重写了某个方法那么子类方法表中该方法的入口地址就会被替换为子类版本的地址。当执行invokevirtual指令时找到操作数栈顶的对象的实际类型记作C。在类型C的方法表中查找与被调用方法签名匹配的方法。如果找到则调用。如果没找到则按照继承关系从下往上从C的父类开始依次查找其父类的方法表直到找到为止。如果始终找不到则抛出AbstractMethodError。这个过程完美解释了为什么子类重写的方法优先级更高因为查找是从对象的实际类子类的方法表开始的子类方法表中的重写方法入口已经覆盖了父类的入口。6.3 内联缓存优化频繁的动态查找是有开销的。为了优化性能JIT编译器会使用“内联缓存”技术。它的基本思想是假设某个虚方法调用点如myPet.makeSound()的接收者类型在大多数情况下是固定的比如总是Dog。JIT会生成一段“快速路径”代码直接检查接收者类型是否为预期的Dog如果是则直接跳转到Dog.makeSound()的编译后本地代码地址省去了完整的方法表查找过程。只有当接收者类型不符合预期时比如变成了Cat才退回到慢速的完整查找路径。这种优化使得多态调用的开销在热点代码中变得非常小。7. 设计层面的思考如何正确运用重写理解了技术细节我们更要从设计上思考如何用好重写。7.1 遵循里氏替换原则里氏替换原则是面向对象设计的重要原则之一它指出子类对象必须能够替换掉其父类对象而程序的行为不发生改变。这意味着子类重写父类方法时不应该加强前置条件比如父类方法接受int子类重写为只接受正数也不应该削弱后置条件比如父类方法保证返回非空列表子类重写后可能返回空。子类方法的行为扩展应该是“增强”而非“改变”父类的契约。违反这个原则的重写即使语法上正确也会给程序带来难以察觉的Bug。7.2 使用抽象方法与模板方法模式如果父类中的某个方法必须由子类提供具体实现那么应该将其声明为abstract抽象方法。这从语法上强制子类去重写实现它。这是一种定义契约的方式。更进一步模板方法模式充分利用了重写。父类定义一个算法的骨架模板方法其中一些步骤是具体的另一些是抽象的或可重写的。子类通过重写这些可变的步骤来改变算法的特定行为而不改变算法的整体结构。HttpServlet中的doGet(),doPost()方法就是典型的例子service()方法是模板方法它根据请求类型调用相应的doXxx方法。abstract class DataProcessor { // 模板方法定义了处理流程 public final void process() { // final防止子类改变算法骨架 loadData(); transformData(); // 这一步由子类定制 saveData(); cleanup(); } protected abstract void transformData(); // 抽象方法子类必须实现 protected void loadData() { /* 通用加载逻辑 */ } protected void saveData() { /* 通用保存逻辑 */ } private void cleanup() { /* 内部清理逻辑 */ } } class CSVProcessor extends DataProcessor { Override protected void transformData() { System.out.println(Transforming CSV data...); } }7.3 谨慎重写equals、hashCode和toStringObject类中的equals、hashCode、toString等方法经常需要被重写。重写它们时必须遵守严格的通用约定。equals与hashCode如果重写了equals必须同时重写hashCode以保证相等的对象必须有相等的哈希码。这是HashMap、HashSet等集合类正常工作的基础。toString重写toString可以提供更有意义的对象字符串表示便于调试和日志记录。不恰当的重写比如只重写equals不重写hashCode会导致对象在放入哈希集合后行为异常这种Bug往往难以追踪。8. 调试与排查当调用不符合预期时在实际开发中你可能会遇到方法调用结果和预期不符的情况。以下是一些排查思路检查是否真的是重写首先确认子类方法是否满足了所有重写条件签名、返回类型、访问权限。最快捷的方法是加上Override注解看编译器是否报错。确认对象的运行时类型使用getClass()方法或调试器确认你操作的引用实际指向的对象是什么类型。多态的核心是“运行时类型”。区分静态与实例方法如果你期望多态但没发生检查该方法是否是static的。静态方法调用看左边引用类型。检查方法是否为private或finalprivate方法不存在重写final方法不能被重写。在复杂继承/实现关系中理清MRO对于Python的多继承或Java的接口默认方法冲突明确方法解析顺序。使用__mro__或分析类继承图。使用调试器进行单步跟踪这是最直接的方法。在方法调用处设置断点观察程序实际跳转到了哪个方法实现。我个人在排查一个Spring Boot应用中的问题时曾遇到一个棘手的案例一个Service类继承了某个基类重写了基类的一个protected方法。但在AOP切面中通过this调用该方法时却没有触发切面逻辑。经过排查发现这是因为Spring的AOP默认使用基于接口的JDK动态代理而我的类没有实现接口Spring会使用CGLIB创建子类代理。在代理类内部通过this调用方法走的是代理对象内部的逻辑而this指向的是代理对象本身子类它调用重写的方法时如果方法不是public且调用发生在类内部可能会绕过代理逻辑。最终通过将方法改为public或者通过ApplicationContext获取代理后的Bean再调用解决了问题。这个案例说明在框架环境下继承和重写还会受到代理机制的影响需要更深入的理解。 
长河君 · 2026/8/23 2:20:23 · 阅读 1.2k 深入解析方法重写：从动态绑定到多态实现的核心机制
1. 当父类与子类方法“撞名”一个看似简单却暗藏玄机的起点在面向对象编程的世界里继承是构建复杂、可复用代码体系的基石。它允许我们基于已有的类父类创建新的类子类子类自动获得父类的属性和方法这听起来既优雅又强大。然而当子类中定义了一个与父类同名同参数的方法时一个看似简单的问题就浮出水面程序运行时到底会调用谁这个问题就是方法重写Override的核心。几乎所有面向对象的语言如Java、C、Python、C#、JavaScript等都遵循一个基本规则子类对象调用重名方法时优先调用子类自己的版本。这个规则是动态绑定或多态性的基础。但“优先”二字背后远不止一个简单的结论。它涉及到编译时与运行时的区别、访问权限的影响、静态方法的特殊性以及在复杂继承链中方法解析的路径。很多开发者尤其是初学者往往在遇到一些“反直觉”的情况时才会意识到自己对这条规则的理解可能还不够深入。比如一个Animal类有个makeSound()方法输出“Some generic animal sound”它的子类Dog重写了这个方法输出“Woof!”。当我们用Dog dog new Dog(); dog.makeSound();时输出“Woof!”毫无悬念。但如果引用类型是父类呢Animal myPet new Dog(); myPet.makeSound();结果是什么这就是多态的经典体现答案依然是“Woof!”。因为实际的对象类型Dog决定了调用哪个方法。然而故事并没有结束。如果方法是private的、static的、或者final的呢如果子类只是“重载”而非“重写”呢在多重继承如C或通过原型链实现的继承如JavaScript中查找顺序又是怎样的这些细节才是真正区分“知道”和“理解”的关键。本文将从一个资深开发者的视角不仅厘清方法调用的基本优先级更深入那些容易混淆的边界情况和底层原理让你下次遇到类似问题时能够胸有成竹一眼看穿本质。2. 重写Override的本质动态绑定的胜利要理解优先级必须先彻底搞懂什么是真正的方法重写。重写不是简单的名字相同它有一系列严格的契约。2.1 构成有效重写的严格条件在Java这类强类型语言中方法重写必须满足以下所有条件缺一不可方法名完全相同。参数列表完全相同参数的类型、数量、顺序。即使参数名不同也没用。返回类型兼容在Java 5之前要求返回类型必须完全相同。从Java 5开始引入了协变返回类型允许子类重写方法的返回类型是父类方法返回类型的子类。访问权限不能更严格子类重写方法的访问修饰符public, protected, default不能比父类被重写方法的访问修饰符更严格。例如父类方法是protected子类可以重写为public或protected但不能重写为default或private。不能重写final方法被final修饰的方法无法被重写。不能重写static方法静态方法属于类不属于对象实例因此不存在“重写”只有“隐藏”。异常声明子类重写方法声明的异常范围不能大于父类方法声明的异常范围即子类异常可以是父类异常的子集或者不抛出检查型异常。只有同时满足这些条件编译器才会认为这是一个有效的重写。此时子类方法完全覆盖了父类方法的实现。在运行时JVM以Java为例通过对象实际类型的方法表进行动态查找永远调用实际对象类型子类中的版本。这就是“动态绑定”或“后期绑定”。class Animal { public void makeSound() { System.out.println(Some generic animal sound); } } class Dog extends Animal { Override // 使用Override注解是良好习惯编译器会帮你检查重写是否符合规则 public void makeSound() { // 方法名、参数列表、返回类型、访问权限均符合重写规则 System.out.println(Woof!); } } public class Test { public static void main(String[] args) { Animal myPet new Dog(); // 编译时类型是Animal运行时类型是Dog myPet.makeSound(); // 输出: Woof! 运行时根据实际对象类型(Dog)决定调用哪个方法 } }注意Override注解在Java中不是必须的但强烈建议使用。它可以让编译器在编译期就帮你检查该方法是否真的成功重写了父类方法避免因拼写错误或签名不匹配而导致的“自以为重写”的bug。2.2 “编译看左边运行看右边”的深度解析“编译看左边运行看右边”这句口诀是对多态下方法调用优先级的一个精炼总结但需要正确理解。编译看左边编译器在编译阶段只认引用变量声明时的类型即左边。它根据这个类型来检查你调用的方法是否存在、访问权限是否允许。如果父类引用左边的类型中没有这个方法或者该方法不可见如private编译就会报错。运行看右边到了运行阶段JVM不再关心引用变量的类型而是根据实际创建的对象的类型即new关键字后面的类型右边来决定调用哪个方法实现。它会去实际对象所属类的方法表中查找。这个机制是实现“面向接口编程”和“开闭原则”的关键。我们可以编写依赖于父类或接口的通用代码而在运行时传入不同的子类对象来获得不同的行为无需修改原有代码。3. 优先级规则的例外与边界情况如果所有方法都遵循上述动态绑定那世界就简单了。但语言设计者为了灵活性、安全性或性能设定了一些例外这些地方恰恰是容易踩坑的。3.1 静态方法属于类的“隐藏”而非对象的重写静态方法与类绑定而非与对象实例绑定。因此静态方法不能被重写只能被隐藏。调用哪个静态方法取决于引用变量的编译时类型而不是运行时对象的实际类型。这失去了多态性。class Parent { public static void staticMethod() { System.out.println(Static in Parent); } } class Child extends Parent { public static void staticMethod() { // 这不是重写是隐藏 System.out.println(Static in Child); } } public class TestStatic { public static void main(String[] args) { Parent p new Child(); p.staticMethod(); // 输出: Static in Parent (看引用类型Parent) Child c new Child(); c.staticMethod(); // 输出: Static in Child (看引用类型Child) // 正确的调用静态方法的方式是通过类名 Parent.staticMethod(); // Static in Parent Child.staticMethod(); // Static in Child } }实操心得永远使用类名.静态方法名()的方式来调用静态方法这样可以避免因引用类型导致的混淆代码意图也更清晰。IDE通常也会给出警告提示。3.2 私有方法不可见的屏障私有方法private只在定义它的类内部可见。子类根本“看不到”父类的私有方法因此子类中定义一个与父类私有方法同名同参数的方法不构成重写而是子类的一个全新的方法。这两个方法在各自类的范围内独立存在。class Parent { private void privateMethod() { System.out.println(Private in Parent); } public void callPrivate() { privateMethod(); // 这里调用的永远是Parent自己的privateMethod } } class Child extends Parent { // 这不是重写只是Child自己的一个方法与Parent的privateMethod无关。 private void privateMethod() { System.out.println(Private in Child); } // 可以重写public方法 Override public void callPrivate() { // super.callPrivate(); // 如果调用父类方法里面还是执行Parent的privateMethod System.out.println(Childs callPrivate); privateMethod(); // 这里调用的是Child自己的privateMethod } } public class TestPrivate { public static void main(String[] args) { Parent p new Child(); p.callPrivate(); // 如果Child没重写callPrivate输出Private in Parent。 // 如果Child重写了callPrivate则执行Child的callPrivate输出Childs callPrivate和Private in Child。 } }由于私有方法不可被外部包括子类访问所以不存在子类对象通过父类引用调用到子类私有方法的情况。它的调用完全由定义它的类在编译期决定。3.3 Final方法终结的契约用final修饰的方法表示该方法的设计和实现是“最终版本”不允许任何子类对其进行修改重写。这通常用于确保关键算法、模板方法中的步骤不被篡改或者出于安全、性能的考虑。class SecurityBase { public final void criticalOperation() { // 执行一些关键的安全操作不希望子类改变 System.out.println(Performing critical security operation...); } } class SubClass extends SecurityBase { // 以下代码会导致编译错误 // Override // public void criticalOperation() { ... } }试图重写final方法会在编译期直接报错。因此final方法的调用优先级是确定且唯一的永远调用父类中定义的版本。3.4 构造方法特殊的初始化过程构造方法名必须与类名相同因此父子类的构造方法名天生不同不存在“重写”的概念。但存在调用链。子类构造方法的第一行如果没有显式写出编译器会自动插入对父类无参构造方法super()的调用。如果父类没有无参构造子类必须显式调用父类的有参构造。构造方法的调用顺序是从最顶层的父类向下直到当前子类。在构造方法中调用可重写的方法是危险的做法因为此时子类的字段可能还未初始化。4. 方法重载Overload与重写的混淆区重载发生在同一个类中或父子类之间其核心是方法名相同但参数列表不同。返回值不同不足以构成重载。当重载遇上继承调用哪个方法的判断逻辑与重写不同。4.1 父子类间的重载解析对于重载方法编译器在编译期就根据方法签名方法名参数列表和引用变量的编译时类型来确定调用哪一个。这是一个静态绑定的过程。class Printer { public void print(String s) { System.out.println(Printing String: s); } public void print(Integer i) { System.out.println(Printing Integer: i); } } class AdvancedPrinter extends Printer { // 重载了父类的print方法增加了一个新版本 public void print(Double d) { System.out.println(Printing Double: d); } // 这里也可以选择重写父类的某个print方法 Override public void print(String s) { System.out.println(Advanced Printing String: s); } } public class TestOverload { public static void main(String[] args) { Printer p new AdvancedPrinter(); p.print(Hello); // 输出: Advanced Printing String: Hello (动态绑定重写生效) p.print(100); // 输出: Printing Integer: 100 (静态绑定根据编译时类型Printer找到参数最匹配的print(Integer)) // p.print(3.14); // 编译错误编译时类型Printer没有print(Double)方法 AdvancedPrinter ap new AdvancedPrinter(); ap.print(3.14); // 输出: Printing Double: 3.14 (编译时类型AdvancedPrinter有自己的print(Double)) } }关键点在于重载看编译时类型重写看运行时类型。对于p.print(100)编译器看到p的类型是Printer于是在Printer类中寻找参数最匹配的print方法找到了print(Integer)。虽然运行时对象是AdvancedPrinter但AdvancedPrinter并没有重写print(Integer)所以执行的是父类Printer中的版本。4.2 避免重写与重载的意外交互一个常见的陷阱是自以为在重写实际上却在重载。class Base { public void process(Object obj) { System.out.println(Processing Object in Base); } } class Derived extends Base { // 小心这不是重写因为参数类型不同。这是重载 public void process(String str) { System.out.println(Processing String in Derived); } } public class TestTrap { public static void main(String[] args) { Base b new Derived(); Object o I am a String; b.process(o); // 输出: Processing Object in Base // 编译时b的类型是BaseBase中process(Object)是唯一匹配的。 // 运行时Derived没有重写process(Object)所以调用Base的版本。 // 尽管传入的实际上是一个String对象。 } }要避免这个坑务必使用Override注解。在上面的Derived类中如果你在process(String)前加上Override编译器会立即报错提示你并没有成功重写父类的任何方法因为它签名不匹配。这能帮你及早发现设计意图的错误。5. 复杂继承链与方法解析顺序在单继承语言如Java中方法查找是一条清晰的链从对象的实际类开始沿着继承树向上查找直到找到第一个匹配的方法签名。但在支持多重继承或类似机制的语言中情况更复杂。5.1 Java的单继承与接口默认方法Java类是单继承但可以实现多个接口。在Java 8之前接口中的方法都是抽象的不存在实现冲突。Java 8引入了默认方法default方法这使得一个类可能从多个接口继承到相同签名的方法实现从而产生冲突。冲突解决规则如下类优先如果一个类继承了父类的具体方法和接口的默认方法签名相同那么父类的方法获胜。接口的默认方法被忽略。接口冲突如果一个类实现了多个接口而这些接口包含了相同签名的默认方法那么这个类必须重写这个方法以消除二义性。在重写的方法中可以通过接口名.super.方法名()的语法来显式调用某个接口的默认实现。interface InterfaceA { default void doSomething() { System.out.println(Default implementation from InterfaceA); } } interface InterfaceB { default void doSomething() { System.out.println(Default implementation from InterfaceB); } } class ParentClass { public void doSomething() { System.out.println(Implementation from ParentClass); } } // 情况1类优先 class MyClass1 extends ParentClass implements InterfaceA { // 从ParentClass继承了doSomethingInterfaceA的默认方法被忽略。 // 调用new MyClass1().doSomething() 会输出 Implementation from ParentClass } // 情况2接口冲突必须重写 class MyClass2 implements InterfaceA, InterfaceB { Override public void doSomething() { // 必须重写否则编译错误 System.out.println(My own implementation); // 或者选择其中一个接口的默认实现 InterfaceA.super.doSomething(); // 调用InterfaceA的默认方法 } }5.2 C中的多重继承与虚函数C支持多重继承一个类可以有多个直接父类。当这些父类有相同签名的虚函数相当于可重写方法时如果子类没有重写就会产生二义性编译器不知道通过子类对象调用时该走哪条路径。必须通过**类名作用域解析运算符::**来显式指定。class Base1 { public: virtual void func() { cout Base1::func endl; } }; class Base2 { public: virtual void func() { cout Base2::func endl; } }; class Derived : public Base1, public Base2 { public: // 如果不重写func下面调用会报错对成员‘func’的请求不明确 // void func() override { cout Derived::func endl; } // 重写后调用自己的版本 }; int main() { Derived d; // d.func(); // 错误二义性 d.Base1::func(); // 正确显式调用Base1的版本 d.Base2::func(); // 正确显式调用Base2的版本 // 通过指针或引用需要类型转换来明确 Base1* b1Ptr d; b1Ptr-func(); // 输出取决于Derived是否重写。若重写输出Derived::func若未重写输出Base1::func。 Base2* b2Ptr d; b2Ptr-func(); // 同理。 }C通过虚函数表vtable来实现动态绑定每个有虚函数的类都有自己的虚函数表。在多重继承下子类对象可能包含多个父类子对象也就可能有多个虚函数表指针。方法调用时需要根据对象的静态类型进行适当的this指针偏移然后查找对应的虚函数表。这是C对象模型中比较复杂的一部分。5.3 Python中的方法解析顺序MROPython支持多继承。为了解决在菱形继承等场景下方法查找的顺序问题Python使用了C3线性化算法来计算一个类的方法解析顺序。你可以通过类名.__mro__属性来查看这个顺序。class A: def process(self): print(A.process) class B(A): def process(self): print(B.process) super().process() # 会调用MRO中的下一个类的process class C(A): def process(self): print(C.process) super().process() class D(B, C): def process(self): print(D.process) super().process() print(D.__mro__) # 输出: (class __main__.D, class __main__.B, class __main__.C, class __main__.A, class object) d D() d.process() # 输出: # D.process # B.process # C.process # A.processPython的super()是一个动态对象它并不是简单地调用“父类”而是按照__mro__列表的顺序去调用“下一个”类的方法。这种设计使得在协作式多继承中每个类都可以通过super()将调用传递给MRO链上的下一个类共同完成一个操作而无需知道具体的继承结构。6. 从原理到实践JVM中的方法调用与分派理解语言特性背后的实现机制能让我们对规则有更深刻的认识。以Java为例方法调用在JVM层面主要分为几种指令其优先级逻辑就蕴含其中。6.1 虚方法与非虚方法非虚方法在编译期就能确定具体调用版本的方法包括静态方法、私有方法、实例构造器、父类方法通过super调用以及被final修饰的方法。它们使用invokestatic调用静态方法、invokespecial调用构造器、私有方法、父类方法指令调用。虚方法其他所有方法即可以被重写的方法。它们使用invokevirtual大多数实例方法或invokeinterface调用接口方法指令调用。虚方法的调用目标需要在运行时根据接收者的实际类型来确定。6.2 方法表与动态查找每个类在加载后JVM会为其创建一个方法表这是一个数组存放了该类的所有方法的入口地址。子类的方法表会包含父类方法表的副本但如果子类重写了某个方法那么子类方法表中该方法的入口地址就会被替换为子类版本的地址。当执行invokevirtual指令时找到操作数栈顶的对象的实际类型记作C。在类型C的方法表中查找与被调用方法签名匹配的方法。如果找到则调用。如果没找到则按照继承关系从下往上从C的父类开始依次查找其父类的方法表直到找到为止。如果始终找不到则抛出AbstractMethodError。这个过程完美解释了为什么子类重写的方法优先级更高因为查找是从对象的实际类子类的方法表开始的子类方法表中的重写方法入口已经覆盖了父类的入口。6.3 内联缓存优化频繁的动态查找是有开销的。为了优化性能JIT编译器会使用“内联缓存”技术。它的基本思想是假设某个虚方法调用点如myPet.makeSound()的接收者类型在大多数情况下是固定的比如总是Dog。JIT会生成一段“快速路径”代码直接检查接收者类型是否为预期的Dog如果是则直接跳转到Dog.makeSound()的编译后本地代码地址省去了完整的方法表查找过程。只有当接收者类型不符合预期时比如变成了Cat才退回到慢速的完整查找路径。这种优化使得多态调用的开销在热点代码中变得非常小。7. 设计层面的思考如何正确运用重写理解了技术细节我们更要从设计上思考如何用好重写。7.1 遵循里氏替换原则里氏替换原则是面向对象设计的重要原则之一它指出子类对象必须能够替换掉其父类对象而程序的行为不发生改变。这意味着子类重写父类方法时不应该加强前置条件比如父类方法接受int子类重写为只接受正数也不应该削弱后置条件比如父类方法保证返回非空列表子类重写后可能返回空。子类方法的行为扩展应该是“增强”而非“改变”父类的契约。违反这个原则的重写即使语法上正确也会给程序带来难以察觉的Bug。7.2 使用抽象方法与模板方法模式如果父类中的某个方法必须由子类提供具体实现那么应该将其声明为abstract抽象方法。这从语法上强制子类去重写实现它。这是一种定义契约的方式。更进一步模板方法模式充分利用了重写。父类定义一个算法的骨架模板方法其中一些步骤是具体的另一些是抽象的或可重写的。子类通过重写这些可变的步骤来改变算法的特定行为而不改变算法的整体结构。HttpServlet中的doGet(),doPost()方法就是典型的例子service()方法是模板方法它根据请求类型调用相应的doXxx方法。abstract class DataProcessor { // 模板方法定义了处理流程 public final void process() { // final防止子类改变算法骨架 loadData(); transformData(); // 这一步由子类定制 saveData(); cleanup(); } protected abstract void transformData(); // 抽象方法子类必须实现 protected void loadData() { /* 通用加载逻辑 */ } protected void saveData() { /* 通用保存逻辑 */ } private void cleanup() { /* 内部清理逻辑 */ } } class CSVProcessor extends DataProcessor { Override protected void transformData() { System.out.println(Transforming CSV data...); } }7.3 谨慎重写equals、hashCode和toStringObject类中的equals、hashCode、toString等方法经常需要被重写。重写它们时必须遵守严格的通用约定。equals与hashCode如果重写了equals必须同时重写hashCode以保证相等的对象必须有相等的哈希码。这是HashMap、HashSet等集合类正常工作的基础。toString重写toString可以提供更有意义的对象字符串表示便于调试和日志记录。不恰当的重写比如只重写equals不重写hashCode会导致对象在放入哈希集合后行为异常这种Bug往往难以追踪。8. 调试与排查当调用不符合预期时在实际开发中你可能会遇到方法调用结果和预期不符的情况。以下是一些排查思路检查是否真的是重写首先确认子类方法是否满足了所有重写条件签名、返回类型、访问权限。最快捷的方法是加上Override注解看编译器是否报错。确认对象的运行时类型使用getClass()方法或调试器确认你操作的引用实际指向的对象是什么类型。多态的核心是“运行时类型”。区分静态与实例方法如果你期望多态但没发生检查该方法是否是static的。静态方法调用看左边引用类型。检查方法是否为private或finalprivate方法不存在重写final方法不能被重写。在复杂继承/实现关系中理清MRO对于Python的多继承或Java的接口默认方法冲突明确方法解析顺序。使用__mro__或分析类继承图。使用调试器进行单步跟踪这是最直接的方法。在方法调用处设置断点观察程序实际跳转到了哪个方法实现。我个人在排查一个Spring Boot应用中的问题时曾遇到一个棘手的案例一个Service类继承了某个基类重写了基类的一个protected方法。但在AOP切面中通过this调用该方法时却没有触发切面逻辑。经过排查发现这是因为Spring的AOP默认使用基于接口的JDK动态代理而我的类没有实现接口Spring会使用CGLIB创建子类代理。在代理类内部通过this调用方法走的是代理对象内部的逻辑而this指向的是代理对象本身子类它调用重写的方法时如果方法不是public且调用发生在类内部可能会绕过代理逻辑。最终通过将方法改为public或者通过ApplicationContext获取代理后的Bean再调用解决了问题。这个案例说明在框架环境下继承和重写还会受到代理机制的影响需要更深入的理解。