Method overloading

Three names for one idea

What is method overloading?

Words you'll meet in this lesson

What counts as a different parameter list?

Three ways to overload, and where you've already seen them

The JDK is full of overloads

public class Main {
    public static void main(String[] args) {
        System.out.println(42);            // println(int)
        System.out.println(4.5);           // println(double)
        System.out.println('A');           // println(char)
        System.out.println("Chai");        // println(String)
        System.out.println(Math.abs(-7));    // abs(int)    returns int
        System.out.println(Math.abs(-7.5));  // abs(double) returns double
        System.out.println(String.valueOf(true) + String.valueOf(99));
    }
}

Each line calls a different method that happens to share a name. Notice that the two Math.abs methods also return different types. That's allowed, because their parameters differ too.

Constructors can be overloaded too

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<>();      // ArrayList()
        ArrayList<String> b = new ArrayList<>(500);   // ArrayList(int initialCapacity)
        StringBuilder s1 = new StringBuilder();          // StringBuilder()
        StringBuilder s2 = new StringBuilder("Bill: ");  // StringBuilder(String)
        System.out.println(a.size() + " " + b.size() + " [" + s1 + "] [" + s2 + "]");
    }
}

How javac chooses one method for a call

1. Collect every method with that name

   static void show(long x)    { System.out.println("long"); }
   static void show(Integer x) { System.out.println("Integer"); }
   static void show(int... x)  { System.out.println("varargs"); }
   
   show(5);   // which one?

   javac finds the three show methods in the class. Methods with a different name are never considered.

2. Phase 1: exact match or widening only

   The argument 5 is an int. No show(int) exists, but int can widen to long. So show(long) is applicable in phase 1, and javac stops here: it prints long. Boxing and varargs are not even tried.

3. Phase 2: allow boxing and unboxing

   Only if phase 1 finds nothing. Remove show(long) and the call boxes 5 into an Integer: it prints Integer.

4. Phase 3: allow varargs

   Last resort. Remove the first two and show(int...) is used: the JVM receives a new int[]{5}. Varargs come in Lesson 5.6.

5. Several fit in the same phase? Pick the most specific, or fail

   Main.java:6: error: reference to add is ambiguous
       add(1, 1);
       ^
     both method add(int,long) in Main and method add(long,int) in Main match

   If one candidate's parameters are all “narrower” than another's, it wins (String beats Object; int beats long). Here each method is better for one argument and worse for the other, so neither is more specific: compile error.

6. The choice is written into the bytecode

   invokestatic  #33   // Method area:(I)I
   invokestatic  #42   // Method area:(II)I
   invokestatic  #47   // Method area:(D)D

   Each call instruction names the method and its descriptor: (I)I means “takes an int, returns an int”, (D)D double to double. The JVM never has to choose; javac already did.

Three calls, three different methods

Left: the call you write and what it prints. Right: how javac matches the arguments to a signature and what it writes into the class file.

Where overloading shows up in real code

Overloading is how good APIs stay easy to use: one name to remember, and sensible defaults for the details you don't care about.

Watch it with an example: one pay() name, three ways to pay

A canteen app has three pay methods. Each call below has different arguments, so javac connects it to a different method before the app ever runs.

Examples are simplified. Library designers keep overload sets small and consistent; when two overloads would behave differently, they choose different method names instead.

Riya's bill calculator with overloads

public class Main {
    static int total(int a, int b) {
        return total(a, b, 0);
    }

    static int total(int a, int b, int c) {
        return a + b + c;
    }

    static double total(int a, int b, double discount) {
        return (a + b) * (1 - discount);
    }

    public static void main(String[] args) {
        System.out.println("Tea + Vada: " + total(10, 25));
        System.out.println("Tea + Vada + Samosa: " + total(10, 25, 15));
        System.out.println("With 10% off: " + total(40, 60, 0.10));
    }
}

• total(int a, int b)The short version doesn't repeat the logic: it calls the three-int version with 0.
• total(int, int, int) vs total(int, int, double)Same count, different type of the third parameter: a valid overload.
• total(10, 25, 15)15 is an int, so the exact match (int, int, int) wins over widening to double.
• total(40, 60, 0.10)0.10 is a double, so only the discount version applies. It returns a double: 90.0.

One overload calling another

The two-argument total delegates to the three-argument one. Watch two frames with the same method name sit on the stack at the same time.

Worked examples: real problems, solved and traced in memory

Three everyday problems where overloading keeps the code short. In each one, the simple versions delegate to a full version, so the real rule is written once. Run each solution, then step through it.

10 km normal, 10 km at 1.5x surge

Normal: Rs 120.0
Peak: Rs 180.0

square side 4, plot 12 x 9, tank radius 1.5

Room: 16 sq ft
Plot: 108 sq ft
Tank: 7.0649999999999995 sq m

Pen Rs 10 (1 piece), Notebook Rs 45 x 3

Pen x1 = Rs 10
Notebook x3 = Rs 135

Check yourself

Quick revision

Interview and viva questions

Practice problems

Write overloads, predict which one javac chooses, and fix the classic mistakes. The last three are real business tasks.

max(4, 9), max(7, 2, 5)

9
7

public class Main {
    static int max(int a, int b) {
        return a > b ? a : b;
    }

    static int max(int a, int b, int c) {
        return max(max(a, b), c);
    }

    public static void main(String[] args) {
        System.out.println(max(4, 9));
        System.out.println(max(7, 2, 5));
    }
}

describe(42), describe(3.5), describe("UPI")

int: 42
double: 3.5
String: UPI (3 chars)

public class Main {
    static void describe(int x)    { System.out.println("int: " + x); }
    static void describe(double x) { System.out.println("double: " + x); }
    static void describe(String x) { System.out.println("String: " + x + " (" + x.length() + " chars)"); }

    public static void main(String[] args) {
        describe(42);
        describe(3.5);
        describe("UPI");
    }
}

show((byte) 3), show('C'), show(10L), show(2.5f)

3 -> int
67 -> int
10.0 -> double
2.5 -> double

public class Main {
    static void show(int x)    { System.out.println(x + " -> int"); }
    static void show(double x) { System.out.println(x + " -> double"); }

    public static void main(String[] args) {
        show((byte) 3);
        show('C');
        show(10L);
        show(2.5f);
    }
}

pick(5), pick(Integer.valueOf(5)), pick(5, 6)

long
Integer
varargs (2 values)

public class Main {
    static void pick(long x)    { System.out.println("long"); }
    static void pick(Integer x) { System.out.println("Integer"); }
    static void pick(int... x)  { System.out.println("varargs (" + x.length + " values)"); }

    public static void main(String[] args) {
        pick(5);
        pick(Integer.valueOf(5));
        pick(5, 6);
    }
}

250 paise, Rs 40 doubled

2.5
80

public class Main {
    static double toRupees(int paise) {
        return paise / 100.0;
    }

    static int doubled(int amount) {
        return amount * 2;
    }

    public static void main(String[] args) {
        System.out.println(toRupees(250));
        System.out.println(doubled(40));
    }
}

2 kg normal, 2 kg express, 5 kg normal

2 kg: Rs 60
2 kg express: Rs 120
5 kg: Rs 90

public class Main {
    static int shipping(int kg) {
        return shipping(kg, false);
    }

    static int shipping(int kg, boolean express) {
        int cost = 40 + 10 * kg;
        if (express) {
            cost += 60;
        }
        return cost;
    }

    public static void main(String[] args) {
        System.out.println("2 kg: Rs " + shipping(2));
        System.out.println("2 kg express: Rs " + shipping(2, true));
        System.out.println("5 kg: Rs " + shipping(5));
    }
}

phone 9876543210, account "001234567890"

XXXXXX3210
XXXXXXXX7890

public class Main {
    static String mask(String accountNo) {
        int keep = 4;
        String last = accountNo.substring(accountNo.length() - keep);
        return "X".repeat(accountNo.length() - keep) + last;
    }

    static String mask(long phone) {
        return mask(String.valueOf(phone));
    }

    public static void main(String[] args) {
        System.out.println(mask(9876543210L));
        System.out.println(mask("001234567890"));
    }
}

50000 for 2 years; at 9% and at 7.5%

Default 9%: Rs 9000.0
At 7.5%:   Rs 7500.0

public class Main {
    static final double DEFAULT_RATE = 9.0;

    static double interest(int principal, int years) {
        return interest(principal, years, DEFAULT_RATE);
    }

    static double interest(int principal, int years, double rate) {
        return principal * rate * years / 100;
    }

    public static void main(String[] args) {
        System.out.println("Default 9%: Rs " + interest(50000, 2));
        System.out.println("At 7.5%:   Rs " + interest(50000, 2, 7.5));
    }
}

Real-world scenario questions (asked in company interviews)

Interviewers like overloading because it tests whether you know what the compiler does, not just the syntax. Think of your answer first, then open the model answer.