Method Overloading vs Overriding in Java

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Compare the signatures

   Overloading changes the parameter list within one class; overriding keeps the exact same signature across a superclass and subclass.

2. Step 2

   Identify the binding time

   Overloading is resolved by the compiler (static); overriding is resolved by the JVM at runtime (dynamic).

3. Step 3

   Check the return type rules

   Return type alone cannot overload; an override must return the same type or a covariant subtype.

4. Step 4

   Respect override constraints

   An override cannot reduce visibility or throw broader checked exceptions, and static/final/private methods can't be overridden.

5. Step 5

   Use @Override to verify

   Annotate overrides so the compiler confirms you truly override rather than accidentally overload.

Code Example

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; } // different params
    int add(int a, int b, int c) { return a + b + c; } // different count
}

public class Demo {
    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println(c.add(2, 3));       // int version
        System.out.println(c.add(2.5, 3.5));   // double version
        System.out.println(c.add(1, 2, 3));    // three-arg version
    }
}

class Animal {
    String sound() { return "Some sound"; }
}

class Dog extends Animal {
    @Override
    String sound() { return "Woof"; } // same signature, redefined
}

public class Demo {
    public static void main(String[] args) {
        Animal a = new Dog();       // reference type Animal
        System.out.println(a.sound()); // prints Woof — resolved at runtime
    }
}

Follow-up Questions

• Why can't the return type alone distinguish overloaded methods?
• What is covariant return type in overriding?
• Can you override a static method, and what actually happens?
• How do access modifiers and checked exceptions constrain an override?
• How does the @Override annotation help catch bugs?