Method Overloading

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Overloading

Declaring several methods with the same name but different parameter lists in the same class.

Overload resolution

The compiler's process for choosing which overloaded method a call refers to.

Static type

The type a variable is declared with, which the compiler knows. In Object o = "hi"; the static type of o is Object.

Most specific

Among matching methods, the one whose parameter types are narrower. f(String) is more specific than f(Object), because every String is an Object.

Boxing

Automatically wrapping a primitive in its wrapper object, such as int 5 into an Integer. Unboxing is the reverse.

Ambiguous call

A call that matches two methods equally well, so the compiler refuses to guess.

Overriding

A subclass replacing an inherited method with the same signature. Chosen at run time, unlike overloading. Covered in Topic 5.3.

1. 1

   Remove an overload and predict the new winner

   In "The three phases", delete f(long). Before running, predict what f(5), f(b) and f(c) print now. (Phase 1 now finds nothing for int, so phase 2 boxes: f(5) prints f(Integer); byte boxes to Byte and char to Character, which match only f(Object).)

2. 2

   Make null ambiguous

   In "Static types decide", add static String describe(Integer i). Compile and read the error for describe(null). Fix it with a cast: describe((String) null).

3. 3

   Count println's overloads

   Run javap java.io.PrintStream | grep println (or findstr println on Windows). You'll see one line per overload: boolean, char, int, long, float, double, char[], String, Object, and the no-argument version.

   terminalcopy cmd

   $ javap java.io.PrintStream | grep println

   ── expected output ──

   public void println();

   public void println(boolean);

   public void println(char);

   public void println(int);

   public void println(long);

   public void println(float);

   public void println(double);

   public void println(char[]);

   public void println(java.lang.String);

   public void println(java.lang.Object);

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

static int area(int side) { return side * side; }
static double area(int side) { return side * side; }

static int sum(int a, long b) { return 1; }
static int sum(long a, int b) { return 2; }
public static void main(String[] args) {
    System.out.println(sum(1, 2));
}

1. 1

   Two methods in a class may share a name if their parameter lists differ: in the number of parameters, their types, or their order. area(int side), area(int width, int height) and area(double radius) can all live together.

2. 2

   The return type alone can't distinguish overloads, and neither can parameter names. int area(int s) and double area(int s) clash with method area(int) is already defined, because the call area(3) wouldn't say which one you mean.

3. 3

   The choice is made by the compiler, from the declared (static) types of the arguments. If Object o = "hi"; then describe(o) calls describe(Object), even though the object is really a String. This is the key difference from overriding (Topic 5.3), which is chosen at run time.

4. 4

   When no overload matches exactly, the compiler tries conversions in three phases: first only widening (like int to long, or String to Object); then boxing/unboxing (int to Integer); and only last varargs (Topic 3.5). The first phase that finds any match wins, and within it the most specific method is chosen.

5. 5

   If two candidates are equally specific, the call is ambiguous and won't compile. You fix it by casting an argument or renaming a method.

6. 6

   You use overloading every day: System.out.println has ten overloads (for int, double, char, String, Object and more), and Math.max has versions for int, long, float and double.

• ↔

  Overloading gives callers a natural, short API (max, println), but overloads with the same arity and related types confuse readers and can pick an unexpected method. Prefer distinct names when meanings differ (removeAt vs removeValue).

• ↔

  Overloads as default arguments keep calls short, but each extra overload is more surface to document and test. Past two or three, a builder or a parameter object scales better.

• Done when you can write a set of overloads and say which one each call picks.

• Done when you can explain why return type alone can't overload.

• Done when you can apply the three phases: widening, then boxing, then varargs.

• Done when you can explain why the declared type, not the object, decides the overload.

• Done when you can diagnose and fix an ambiguous call.