Method Overloading

Method Overloading allows multiple methods in the same class to share the same name but have different parameter lists. It is a form of compile-time (static) polymorphism where the compiler decides which method to invoke at compile time.

Compiler Resolution Precedence Order

When a method is invoked, the Java compiler selects the most specific overloaded signature using the following priority order:

1. Exact Match: The argument types match the parameter types exactly.
2. Widening (Implicit Numeric Promotion): Primitives are widened to larger primitive types (e.g., int is promoted to long, then to float, and then to double).
3. Autoboxing / Unboxing: Primitives are converted to their wrapper objects (e.g. int to Integer), or objects are unboxed to primitives.
4. Varargs: Varargs parameters are evaluated last because they have the lowest priority.

Note on Widening vs. Autoboxing: In Java, widening takes precedence over autoboxing. The compiler favors promoting an int to a long over boxing it to an Integer. This design preserves compatibility with older Java versions that did not support autoboxing.

Ambiguity Compilation Errors

Ambiguity occurs when the compiler finds multiple signatures that match a method call equally well, making it impossible to determine the intended method. For example:

void process(int a, long b) { }
void process(long a, int b) { }
// Calling this method:
process(10, 10); // COMPILE ERROR: Reference to process is ambiguous

Both arguments are int literals. The compiler can widen the first argument to match the second method, or widen the second argument to match the first. Since both options are equally valid, the compiler throws an ambiguity error.

Common Pitfalls

• Changing only Return Types: Expecting methods to overload by changing the return type, which causes a duplicate method signature compilation error.
• Introducing Ambiguity: Overloading methods with broad type promotions (e.g. double vs float) that result in compile-time ambiguity.
• Passing Null to Overloaded Methods: Invoking a method with null when signatures exist for both String and Integer, causing compile errors because both types are references.

Best Practices

• Only overload methods when they perform the same conceptual action on different data types. If the actions are different, give them different names.
• Avoid overloading methods with parameter lists that differ only by primitive widening promotions (e.g., int vs long).
• When overloading constructors, chain them using this() to centralize initialization logic.

Interview-Relevant Information