Compile-time polymorphism in Java - Step-by-Step Execution

Concept Flow - Compile-time polymorphism

Start

↓

Call method with arguments

↓

Compiler checks method signatures

↓

Select method matching argument types

↓

Execute selected method

↓

End

At compile time, Java decides which method to call based on the method name and argument types.

Execution Sample

Java

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

This code shows two methods named show with different argument types; Java chooses which to call based on the argument.

Execution Table

Step	Method Call	Argument Type	Method Selected	Output
1	d.show(5)	int	show(int a)	int: 5
2	d.show("Hi")	String	show(String a)	String: Hi
3	End of main	-	-	-

💡 All method calls resolved at compile time by matching argument types.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
d	null	Demo object	Demo object	Demo object
a (int)	N/A	5	N/A	N/A
a (String)	N/A	N/A	"Hi"	N/A

Key Moments - 2 Insights

Why does Java choose which show method to call before running the program?

Because Java uses compile-time polymorphism, it decides which method to call by looking at the argument types during compilation, as shown in execution_table steps 1 and 2.

What happens if you call show with a type that doesn't match any method?

The compiler will give an error because it cannot find a matching method signature, so no method is selected.

Visual Quiz - 3 Questions

Look at the execution table, which method is called when d.show(5) is executed?

A show(int a)

B show(String a)

C show(double a)

D No method is called

💡 Hint

Check the first row of the execution_table where argument type is int.

At which step does the method show(String a) get called?

A Step 1

B Step 2

C Step 3

D Never

💡 Hint

Look at the second row of the execution_table for method selection.

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

A show(int a) is called

B show(String a) is called

C show(double a) is called

D Compilation error

💡 Hint

Compile-time polymorphism selects method matching argument type exactly.

Concept Snapshot

Compile-time polymorphism (method overloading) means multiple methods have the same name but different parameters.
Java decides which method to call during compilation by matching argument types.
This allows methods to behave differently based on input types.
If no matching method is found, compilation fails.
Example: show(int) and show(String) are two overloaded methods.

Full Transcript

Compile-time polymorphism in Java means the program decides which method to call before running, based on the method name and argument types. In the example, the class Demo has two methods named show: one takes an int and the other a String. When main calls d.show(5), Java chooses show(int a) because the argument is an int. When d.show("Hi") is called, Java chooses show(String a). This decision happens during compilation, so the program knows exactly which method to run. If you try to call show with a type that doesn't match any method, the compiler will give an error. This is called method overloading and helps write clear code that works with different data types.

Practice

1.

What is compile-time polymorphism in Java?

easy

A. Using different method names for different tasks

B. Changing the method behavior at runtime based on object type

C. Using the same method name with different parameters in the same class

D. Creating multiple classes with the same name

Solution

1. Step 1: Understand method overloading

   Compile-time polymorphism is also called method overloading, where methods share the same name but differ in parameters.

2. Step 2: Differentiate from runtime polymorphism

   Runtime polymorphism uses method overriding, changing behavior based on object type at runtime, not compile-time.

3. Final Answer:

   Using the same method name with different parameters in the same class -> Option C

4. Quick Check:

   Compile-time polymorphism = method overloading [OK]

Hint: Same method name, different parameters means compile-time polymorphism [OK]

Common Mistakes:

• Confusing compile-time with runtime polymorphism
• Thinking method overriding is compile-time polymorphism
• Believing different method names are polymorphism

2.

Which of the following is the correct syntax for method overloading in Java?

public class Calculator {
    public int add(int a, int b) { return a + b; }
    public int add(int a, int b, int c) { ? }
}

easy

A. return a + b + c;

B. return a + b;

C. return a * b * c;

D. return a - b - c;

Solution

1. Step 1: Check method parameters

   The second add method has three parameters, so it should add all three values.

2. Step 2: Write correct return statement

   Return the sum of a, b, and c to correctly overload the add method.

3. Final Answer:

   return a + b + c; -> Option A

4. Quick Check:

   Overloaded method sums all parameters [OK]

Hint: Overloaded methods must handle all their parameters correctly [OK]

Common Mistakes:

• Returning sum of only two parameters in three-parameter method
• Using wrong operators like multiplication or subtraction
• Syntax errors like missing semicolon

3.

What will be the output of the following Java code?

class Demo {
    void show(int a) { System.out.println("Int: " + a); }
    void show(String a) { System.out.println("String: " + a); }
}
public class Test {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.show(5);
        d.show("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 overloaded methods

   There are two show methods: one takes int, the other takes String.

2. Step 2: Match method calls to parameters

   d.show(5) calls show(int), printing "Int: 5"; d.show("Hello") calls show(String), printing "String: Hello".

3. Final Answer:

   Int: 5\nString: Hello -> Option A

4. Quick Check:

   Method overloading calls correct method by parameter type [OK]

Hint: Method chosen by parameter type at compile time [OK]

Common Mistakes:

• Confusing parameter types and outputs
• Expecting runtime polymorphism behavior
• Thinking it causes compilation error

4.

Find the error in this code snippet related to compile-time polymorphism:

class Test {
    void display(int a) { System.out.println(a); }
    void display(int a, int b) { System.out.println(a + b); }
    void display(int a) { System.out.println(a * 2); }
}

medium

A. Incorrect method parameter types

B. Duplicate method display(int a) causes compilation error

C. Missing return type in one method

D. No error, code compiles fine

Solution

1. Step 1: Check method signatures

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

2. Step 2: Understand method overloading rules

   Method overloading requires different parameter lists; duplicate signatures cause compilation error.

3. Final Answer:

   Duplicate method display(int a) causes compilation error -> Option B

4. Quick Check:

   Duplicate method signatures cause compile error [OK]

Hint: Overloaded methods must differ in parameter list [OK]

Common Mistakes:

• Thinking method bodies affect overloading
• Ignoring duplicate parameter lists
• Assuming code compiles without error

5.

Consider this class:

class Printer {
    void print(int a) { System.out.println("Number: " + a); }
    void print(String a) { System.out.println("Text: " + a); }
    void print(int a, String b) { System.out.println(a + " and " + b); }
}

Which call will cause a compile-time error?

hard

A. print("Test")

B. print(10, "Hello")

C. print(5)

D. print("Hello", 10)

Solution

1. Step 1: Check method signatures

   Methods accept (int), (String), and (int, String) parameters.

2. Step 2: Match call parameters

   print("Hello", 10) tries to call (String, int), which does not exist, causing compile error.

3. Final Answer:

   print("Hello", 10) -> Option D

4. Quick Check:

   No matching method for (String, int) call [OK]

Hint: Check parameter order and types carefully for overloaded methods [OK]

Common Mistakes:

• Assuming parameter order doesn't matter
• Thinking all combinations are allowed
• Ignoring method signature mismatch