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 enables methods to perform similar but slightly different tasks based on the type or number of arguments passed to them. Method overloading is a key concept in object-oriented programming that enhances code readability and reusability.

Key Characteristics of Method Overloading:

1. Same Method Name:

   • All overloaded methods must have the same name.

2. Different Parameter Lists:

   • Overloaded methods must have different parameter types, number of parameters, or both. The method signature (which includes the method name and parameter list) must be unique for each overloaded method.

3. Return Type:

   • The return type can be the same or different for overloaded methods, but it alone does not distinguish them; the parameter list is what differentiates them.

4. Compile-time Polymorphism:

   • Method overloading is a form of compile-time polymorphism, meaning the method that gets executed is determined at compile time based on the method signature.

Example of Method Overloading

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

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

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

// Main class to demonstrate method overloading
public class Main {
    public static void main(String[] args) {
        MathOperations math = new MathOperations();

        // Calling overloaded methods
        int sum1 = math.add(5, 10);               // Calls add(int a, int b)
        int sum2 = math.add(5, 10, 15);           // Calls add(int a, int b, int c)
        double sum3 = math.add(5.5, 10.5);        // Calls add(double a, double b)

        // Displaying results
        System.out.println("Sum of two integers: " + sum1);        // Output: Sum of two integers: 15
        System.out.println("Sum of three integers: " + sum2);      // Output: Sum of three integers: 30
        System.out.println("Sum of two doubles: " + sum3);         // Output: Sum of two doubles: 16.0
    }
}

Explanation:

• The MathOperations class contains three overloaded methods named add:
  • add(int a, int b): Adds two integers.
  • add(int a, int b, int c): Adds three integers.
  • add(double a, double b): Adds two double values.
• In the main method, an instance of MathOperations is created, and each overloaded add method is called with different arguments.
• The correct method is invoked based on the number and type of arguments passed.

Advantages of Method Overloading:

1. Code Readability:

   • Having multiple methods with the same name can make the code easier to read and understand, as it groups similar actions together.

2. Flexibility:

   • Allows the same method name to perform different tasks based on varying input, enhancing flexibility in the code.

3. Increased Usability:

   • Users of the class can call the same method name with different parameters, simplifying the interface and improving usability.

Summary:

• Method overloading allows a class to have multiple methods with the same name but different parameter lists.
• It is an essential feature in Java that supports compile-time polymorphism, enhances code readability, and provides flexibility in method usage.
• Overloaded methods can perform similar actions on different types or numbers of inputs, promoting cleaner and more maintainable code.