Method Overriding

Method Overriding allows a subclass to provide a specific implementation of a method that is already declared in its superclass. This mechanism forms the foundation of Runtime Polymorphism (Dynamic Binding) in Java.

Runtime Dynamic Method Dispatch (vtable)

Dynamic binding is how Java decides which method to run. At compile time, the compiler only verifies that the reference variable's type contains the declared method. At runtime, the JVM looks at the actual object on the heap:

• Every loaded class has a vtable (Virtual Method Table) in Metaspace containing entry points for all instance methods.
• When calling animal.makeSound(), the JVM identifies the exact class of the heap object, indexes its vtable, and calls the resolved method implementation.
• If the subclass does not override, the vtable inherits the parent class pointer. If it does, the pointer is updated to the subclass method.

Checked Exception Rules in Overriding

To preserve polymorphism, the compiler enforces strict bounds on exceptions:

• An overriding subclass method can throw fewer or narrower (more specific) checked exceptions. For example, if the parent method declares throws IOException, the child can declare throws FileNotFoundException or omit the clause entirely.
• An overriding subclass method cannot throw broader or new checked exceptions (e.g., throwing Exception when parent throws IOException). This prevents callers using a parent reference from receiving unhandled checked exceptions.
• The subclass method can declare any unchecked exceptions (e.g., NullPointerException) without restriction.

Static Method Hiding

Static methods cannot be overridden. If a subclass declares a static method with the same signature as a superclass static method, it is called method hiding. The method executed depends on the compiler's reference type rather than the runtime object type, as static calls are bound at compile time.

Common Pitfalls

• Attempting to override static methods: Writing static methods in subclasses and expecting polymorphic runtime behavior, resulting in compile-time binding executing parent methods.
• Narrowing access permissions: Attempting to override a public parent method with protected or default access in the subclass, yielding a compiler error.

Best Practices

• Always Use the @Override Annotation: This enables the compiler to verify that your signature matches a parent method, catching typos and argument mismatches early.
• Keep Exception Declarations Narrow: Only throw specific exceptions that represent direct failure paths of the subclass logic.

Interview-Relevant Information