JAVA Tutorial

Method Overloading in Java

Method Overloading is a feature in Java where multiple methods can have the same name but different parameters. It allows methods to perform different tasks based on the number or type of parameters passed to them.

What is Method Overloading?

In method overloading, you can define multiple methods with the same name in a class, as long as they have different method signatures. The method signature includes the method name and the parameter list (number and type of parameters).

Syntax of Method Overloading

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

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

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

In the example above, the add method is overloaded three times with different parameter types and numbers of parameters.

Why Use Method Overloading?

• Improved Readability: Overloading allows using the same method name for similar operations, making the code more readable and intuitive.
• Code Reusability: You don't need to write separate methods for each operation; instead, you can overload a method to handle different inputs.
• Ease of Maintenance: Having a single method name reduces the need for repetitive code, making it easier to maintain.

Example of Method Overloading

Let’s see how method overloading works in Java. The following example demonstrates how different add methods are called based on the arguments passed.

Example Code:

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

        // Calling add method with two integers
        System.out.println("Sum of 2 and 3: " + calc.add(2, 3));

        // Calling add method with three integers
        System.out.println("Sum of 2, 3, and 4: " + calc.add(2, 3, 4));

        // Calling add method with two doubles
        System.out.println("Sum of 2.5 and 3.5: " + calc.add(2.5, 3.5));
    }
}
  

In this example, we are calling the overloaded add methods with different numbers and types of arguments. The correct method is invoked based on the input parameters.

Rules of Method Overloading

• Different Parameter List: The methods must have a different number of parameters or different types of parameters. The method name must be the same.
• Return Type: Method overloading is not determined by return type alone. The parameter list must be different.
• Not Based on Parameter Names: The names of the parameters do not affect method overloading. The parameter types and count must differ.

Example with Return Type (Same Parameter List)

It is important to remember that method overloading is not based on return type alone. The parameters must differ in type, number, or both. Here's an example:

class Calculator {
    // Method with int return type
    public int add(int a, int b) {
        return a + b;
    }

    // Method with double return type (not allowed for overloading by return type alone)
    // public double add(int a, int b) {  // This would cause a compile-time error
    //     return a + b;
    // }
}
  

If you try to overload a method only by changing the return type, you’ll encounter a compile-time error. The parameter list must be different.

Method Overloading vs. Method Overriding

Method overloading is not the same as method overriding. Overloading happens at compile time (static polymorphism), while overriding is a runtime behavior (dynamic polymorphism).

In method overloading, you define multiple methods with the same name but different parameters within the same class, while method overriding involves redefining a method of a superclass in a subclass with the same signature.