Method overloading in Java - Step-by-Step Execution

Concept Flow - Method overloading

Start

↓

Call method with arguments

↓

Check method signatures

↓

Match found?

No→Error: No method found

Yes↓

Execute matched method

↓

Return result

↓

End

When a method is called, Java looks for the method with the matching name and argument types, then runs that method.

Execution Sample

Java

class Demo {
  void show(int a) { System.out.println("Int: " + a); }
  void show(String s) { System.out.println("String: " + s); }
  public static void main(String[] args) {
    Demo d = new Demo();
    d.show(5);
    d.show("Hi");
  }
}

This code calls two versions of show(): one with an int, one with a String.

Execution Table

Step	Method Called	Argument Type	Method Matched	Output
1	show(5)	int	show(int a)	Int: 5
2	show("Hi")	String	show(String s)	String: Hi
3	End	-	-	-

💡 All method calls matched correct overloaded methods and executed successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
a (int)	undefined	5	5	5
s (String)	undefined	undefined	"Hi"	"Hi"

Key Moments - 3 Insights

Why does Java choose show(int a) when we call show(5)?

Because the argument 5 is an int, Java matches it to the method with int parameter as shown in execution_table step 1.

What happens if we call show(5.0) but no method has double parameter?

Java will look for a method with double or compatible type. If none found, it causes a compile error (not shown here).

Can two methods have the same name and same parameter types?

No, method signatures must differ in parameter types or number to overload, otherwise it's a compile error.

Visual Quiz - 3 Questions

Look at the execution table, which method is called when show("Hi") is executed?

A show(int a)

B show(String s)

C show() with no parameters

D No method is called

💡 Hint

Check execution_table row 2 for method matched and output.

At which step does the method with int parameter run?

A Step 1

B Step 2

C Step 3

D No step

💡 Hint

Look at execution_table row 1 for method called and matched.

If we add a method show(double d), what happens when calling show(5.0)?

A show(int a) runs

B Compile error

C show(double d) runs

D show(String s) runs

💡 Hint

Java matches method by exact parameter type, so double argument matches show(double d).

Concept Snapshot

Method overloading means having multiple methods with the same name but different parameters.
Java chooses which method to run based on argument types.
Methods must differ in parameter type or count.
Return type alone does not overload a method.
It helps write cleaner, readable code with same action but different inputs.

Full Transcript

Method overloading in Java allows multiple methods with the same name but different parameter types or counts. When a method is called, Java looks for the method whose parameters match the arguments given. For example, if show(int a) and show(String s) exist, calling show(5) runs the int version, and show("Hi") runs the String version. If no matching method is found, the program will not compile. Overloading helps organize code that does similar things with different inputs. Methods cannot be overloaded by return type alone; parameter differences are required.

Practice

1.

What is method overloading in Java?

easy

A. Changing the return type of a method only

B. Having multiple classes with the same name

C. Using inheritance to override methods

D. Having multiple methods with the same name but different parameters

Solution

1. Step 1: Understand method naming

   Method overloading means methods share the same name.

2. Step 2: Check parameter differences

   They differ by number or type of parameters, not just return type.

3. Final Answer:

   Having multiple methods with the same name but different parameters -> Option D

4. Quick Check:

   Same name + different parameters = method overloading [OK]

Hint: Same method name, different parameters means overloading [OK]

Common Mistakes:

• Confusing overloading with overriding
• Thinking return type alone overloads method
• Mixing class names with method names

2.

Which of the following is a correct method overloading example in Java?

class Test {
  void show(int a) {}
  void show(int a, int b) {}
  void show(int a) {}
}

easy

A. This code compiles without errors

B. Duplicate method show(int a) causes a compile error

C. Method names must be different to overload

D. Return types must differ for overloading

Solution

1. Step 1: Check method signatures

   Two methods have the same name and same parameter list: show(int a).

2. Step 2: Understand overloading rules

   Overloading requires different parameter lists; duplicate signatures cause errors.

3. Final Answer:

   Duplicate method show(int a) causes a compile error -> Option B

4. Quick Check:

   Same parameters = error, not overloading [OK]

Hint: Parameters must differ; identical signatures cause errors [OK]

Common Mistakes:

• Assuming return type difference overloads method
• Ignoring duplicate parameter lists
• Thinking method names must differ

3.

What is the output of this Java code?

class Demo {
  void print(int a) {
    System.out.println("int: " + a);
  }
  void print(String s) {
    System.out.println("String: " + s);
  }
}
public class Main {
  public static void main(String[] args) {
    Demo d = new Demo();
    d.print(5);
    d.print("hello");
  }
}

medium

A. int: 5\nString: hello

B. String: 5\nint: hello

C. int: 5\nint: hello

D. Compilation error

Solution

1. Step 1: Identify method calls and parameters

   First call passes int 5, second call passes String "hello".

2. Step 2: Match calls to overloaded methods

   print(int) prints "int: 5", print(String) prints "String: hello".

3. Final Answer:

   int: 5 String: hello -> Option A

4. Quick Check:

   Correct method chosen by parameter type [OK]

Hint: Method chosen by argument type matches parameter [OK]

Common Mistakes:

• Mixing output order
• Assuming wrong method called
• Expecting compile error

4.

Find the error in this code snippet:

class Calculator {
  int add(int a, int b) { return a + b; }
  double add(double a, double b) { return a + b; }
  int add(int a, int b, int c) { return a + b + c; }
  int add(int a, int b) { return a - b; }
}

medium

A. Duplicate method add(int a, int b) with different body causes error

B. Overloading requires different method names

C. Return type difference causes error

D. No error, code compiles fine

Solution

1. Step 1: Check method signatures

   Two methods have signature add(int a, int b) but different bodies.

2. Step 2: Understand overloading rules

   Overloading requires unique parameter lists; duplicate signatures cause errors regardless of body.

3. Final Answer:

   Duplicate method add(int a, int b) with different body causes error -> Option A

4. Quick Check:

   Same parameters = duplicate method error [OK]

Hint: Same parameters, different body = error, not overloading [OK]

Common Mistakes:

• Thinking different return types fix duplicates
• Ignoring duplicate parameter lists
• Confusing overloading with overriding

5.

Consider this class:

class Converter {
  int convert(String s) { return Integer.parseInt(s); }
  int convert(int i) { return i * 2; }
  int convert(String s, int base) { return Integer.parseInt(s, base); }
}
public class Main {
  public static void main(String[] args) {
    Converter c = new Converter();
    System.out.println(c.convert("10"));
    System.out.println(c.convert(10));
    System.out.println(c.convert("10", 16));
  }
}

What is the output when this code runs?

hard

A. Runtime error parsing string

B. 10\n20\n10

C. 10\n20\n16

D. Compilation error due to ambiguous methods

Solution

1. Step 1: Analyze each method call

   convert("10") parses string "10" as decimal 10; convert(10) doubles 10 to 20; convert("10", 16) parses hex "10" as decimal 16.

2. Step 2: Determine output values

   Outputs are 10, 20, and 16 respectively.

3. Final Answer:

   10 20 16 -> Option C

4. Quick Check:

   Overloaded methods handle inputs correctly [OK]

Hint: Match method by parameters; parseInt with base converts hex [OK]

Common Mistakes:

• Confusing hex parsing result
• Expecting compile or runtime errors
• Mixing method outputs