Compile-time polymorphism in Java - Mini Project: Build & Apply

Compile-time Polymorphism in Java

📖 Scenario: Imagine you are creating a simple calculator program that can add numbers. Sometimes you want to add two numbers, and other times you want to add three numbers. Using compile-time polymorphism, you can create methods with the same name but different numbers of inputs.

🎯 Goal: Build a Java class called Calculator that demonstrates compile-time polymorphism by having two add methods: one that adds two integers and another that adds three integers.

📋 What You'll Learn

Create a class named Calculator.

Inside Calculator, create a method add that takes two int parameters and returns their sum.

Inside Calculator, create another method add that takes three int parameters and returns their sum.

In the main method, create an object of Calculator and call both add methods with appropriate arguments.

Print the results of both method calls.

💡 Why This Matters

🌍 Real World

Compile-time polymorphism is used in many software applications to simplify code and improve readability by using the same method name for similar actions with different inputs.

💼 Career

Understanding method overloading is essential for Java developers as it is a fundamental concept used in designing flexible and reusable code.

1

Create the Calculator class with the main method

Create a public class called Calculator and add a public static void main(String[] args) method inside it.

Java

public class Calculator {
    public static void main(String[] args) {
        // Your code here
    }
}

Hint

Start by writing public class Calculator { and then add the main method inside.

2

Add the first add method with two parameters

Inside the Calculator class but outside the main method, create a public method called add that takes two int parameters named a and b and returns their sum as an int.

Java

public class Calculator {
    public static void main(String[] args) {
        
    }

    // Your code here
}

Hint

Write a method with signature public int add(int a, int b) and return a + b.

3

Add the second add method with three parameters

Inside the Calculator class but outside the main method, create another public method called add that takes three int parameters named a, b, and c and returns their sum as an int.

Java

public class Calculator {
    public static void main(String[] args) {
        
    }

    public int add(int a, int b) {
        return a + b;
    }

    // Your code here
}

Hint

Create a method public int add(int a, int b, int c) that returns a + b + c.

4

Use both add methods and print the results

Inside the main method, create an object of Calculator named calc. Then call calc.add(5, 10) and store the result in an int variable named sumTwo. Next, call calc.add(3, 4, 5) and store the result in an int variable named sumThree. Finally, print both sumTwo and sumThree using System.out.println.

Java

public class Calculator {
    public static void main(String[] args) {
        // Your code here
    }

    public int add(int a, int b) {
        return a + b;
    }

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

Hint

Create an object with new Calculator(), call both add methods, and print the results.

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