Understanding Method Overloading in Java with Examples

Explain Method Overloading in Java. Please give an example

Method overloading in Java is a feature that allows a class to have more than one method with the same name, but with different parameter lists. This means that you can define multiple methods that perform similar functions but take different types or numbers of parameters. The method to be executed is determined at compile time based on the method signature (the method name and the parameter list).

Key Points of Method Overloading:

1. Same Method Name: All overloaded methods must have the same name.
2. Different Parameter Lists: Overloaded methods must differ in the type, number, or order of parameters.
3. Return Type: The return type can be different, but it alone cannot be used to distinguish overloaded methods.
4. Compile-Time Polymorphism: Method overloading is a form of compile-time polymorphism.

Example of Method Overloading

Here’s a simple example to illustrate method overloading in Java:

class MathOperations {
    
    // Method to add two integers
    int add(int a, int b) {
        return a + b;
    }

    // Overloaded method to add three integers
    int add(int a, int b, int c) {
        return a + b + c;
    }

    // Overloaded method to add two double values
    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperations mathOps = new MathOperations();

        // Calling the first add method
        int sum1 = mathOps.add(5, 10); // Calls add(int, int)
        System.out.println("Sum of two integers: " + sum1);

        // Calling the second add method
        int sum2 = mathOps.add(5, 10, 15); // Calls add(int, int, int)
        System.out.println("Sum of three integers: " + sum2);

        // Calling the third add method
        double sum3 = mathOps.add(5.5, 10.5); // Calls add(double, double)
        System.out.println("Sum of two doubles: " + sum3);
    }
}

Explanation of the Example:

• The MathOperations class has three overloaded add methods:
  • The first method takes two integers and returns their sum.
  • The second method takes three integers and returns their sum.
  • The third method takes two double values and returns their sum.
• In the Main class, we create an instance of MathOperations and call each of the overloaded add methods with different arguments. The appropriate method is called based on the number and type of arguments passed.

Output:

Sum of two integers: 15
Sum of three integers: 30
Sum of two doubles: 16.0

This demonstrates how method overloading allows for more flexible and readable code by using the same method name for similar operations that differ in their input parameters.