Method Overloading vs Overriding

Overloading and overriding sound alike and both reuse a method name, so they're easy to mix up. They are actually opposites in almost every way. Overloading is several methods with the same name and different parameters, chosen by the compiler. Overriding is one method replaced in a subclass with the same parameters, chosen by the JVM at runtime. This lesson puts them side by side, then shows a real bug caused by confusing them.

Side by Side

Both in One Program

public class Both {
    static class Printer {
        void print(String s) { System.out.println("Printer: " + s); }
        void print(int n) { System.out.println("Printer number: " + n); }
    }
 
    static class ColorPrinter extends Printer {
        @Override
        void print(String s) { System.out.println("Color: " + s); }
    }
 
    public static void main(String[] args) {
        Printer p = new ColorPrinter();
        p.print("Navika");
        p.print(42);
    }
}

Color: Navika
Printer number: 42

How it works

1. print(String) and print(int) in Printer are overloads. For p.print(42), the compiler picks print(int) from the argument type.
2. ColorPrinter overrides only print(String). For p.print("Navika"), the compiler picks print(String), then at runtime the JVM sees a ColorPrinter object and runs its version.
3. print(int) isn't overridden, so the inherited Printer version runs.

So both mechanisms work together in two steps: the compiler chooses the signature, then the JVM chooses the implementation of that signature.

The equals Trap

This class tries to override equals but actually overloads it:

public class Trap {
    static class Account {
        String id;
        Account(String id) { this.id = id; }
 
        public boolean equals(Account other) {
            return id.equals(other.id);
        }
    }
 
    public static void main(String[] args) {
        Account a = new Account("A-101");
        Account b = new Account("A-101");
        Object o = b;
        System.out.println(a.equals(b));
        System.out.println(a.equals(o));
    }
}

true
false

How it works

1. Object declares equals(Object). The class declares equals(Account): a different parameter type, so it's an overload. Account now has two equals methods.
2. a.equals(b): the argument's declared type is Account, so the compiler picks the new method, which compares ids: true.
3. a.equals(o): the declared type is Object, so the compiler picks the inherited Object.equals, which compares references: false.
4. Collections such as HashSet and ArrayList.contains always call equals(Object), so they'd never use your method.

Common Mistakes

Calling an overload "overriding" in an interview. The parameter list is the deciding question: different means overloading.

Expecting overloads to be chosen by the runtime object. They're chosen by declared types at compile time.

Overloading methods inherited from Object by accident. equals(Account) and compareTo with the wrong type are classic examples.

Interview Corner

Practice

1. Easy: In a Calculator class, overload add for two and three ints. In ScientificCalculator, override the two-argument version to print a log line before adding.
2. Harder: Fix the Trap class so both lines print true, using @Override and a parameter of type Object.

Key Takeaways