Method Overloading With Example In Java

In Java, when multiple methods in the same class have the same name but differ in the number or types of parameters, this is called method overloading. When an overloaded method is invoked, the compiler determines the appropriate method to call based on the number of parameters. If multiple methods have the same number of parameters, the compiler resolves the call based on the parameter types.

In Java, we often use the concept of method overloading in programs. For example, the println() method in Java is overloaded—it can accept different types of arguments, such as integers, strings, and floating-point numbers. Each time println() is invoked with a different argument type, the appropriate overloaded method is called.

System.out.println("Hello Aitechray"); // Prints a string
System.out.println(44); // Prints an integer
System.out.println(true); // Prints a boolean
System.out.println(44.5); // Prints a double
System.out.println(); // Prints a blank line (overloaded println with no parameters)

The first println() prints a string to the console, the second prints an integer, the third prints a boolean, the fourth prints a double, and the last one (with no parameters) prints a blank line.

Why method overloading is used in Java?

Suppose we create a method to add two integer numbers in our program. This method takes two integer parameters, adds them, and displays the result on the console. An example is below:

void sumTwoInts(int x,int y)
{
  int z=x+y;
  System.out.println("Sum is "+z);
}

Now, if we want to add two double numbers, we will create another method that accepts two double parameters, performs the addition, and prints the result. An example is below:

void sumTwoDoubles(double x,double y)
{
  double z=x+y;
  System.out.println("Sum is "+z);
}

Both methods perform the same task—adding two numbers—and managing these two methods is simple and straightforward.

However, if we also want to add two float numbers, two char values, and two long numbers, we would need to create three additional methods with different names. This approach makes the code more complex, harder to maintain, and difficult to remember all the method names. The method headers of all methods are shown below:

void sumTwoInts(int x, int y);
void sumTwoDoubles(double x, double y);
void sumTwoFloats(float x, float y);
void sumTwoLongs(long x, long y);
void sumTwoChars(char x, char y);

To solve this problem, method overloading is used in Java. It allows us to define multiple methods with the same name but with different parameter types or numbers, making the code cleaner, easier to manage, and more readable.

Instead of using different method names, we can use method overloading, where all methods share the same name but have different parameter types. Below is a Java program demonstrating method overloading with a single method name sum().

Method Overloading Example in Java

class Addition {
    // Method to add two integers
    void sum(int x, int y) {
        System.out.println("Sum of two integers: " + (x + y));
    }

    // Method to add two doubles
    void sum(double x, double y) {
        System.out.println("Sum of two doubles: " + (x + y));
    }

    // Method to add two floats
    void sum(float x, float y) {
        System.out.println("Sum of two floats: " + (x + y));
    }

    // Method to add two longs
    void sum(long x, long y) {
        System.out.println("Sum of two longs: " + (x + y));
    }

    // Method to add two characters (adds ASCII values)
    void sum(char x, char y) {
        System.out.println("Sum of two characters (ASCII values): " + (x + y));
    }
}

public class Main {
    public static void main(String[] args) {
        Addition obj = new Addition();
        
        obj.sum(10, 20);         // Calls int version
        obj.sum(5.5, 4.5);       // Calls double version
        obj.sum(2.5f, 3.5f);     // Calls float version
        obj.sum(100000L, 200000L); // Calls long version
        obj.sum('A', 'B');       // Calls char version (adds ASCII values)
    }
}

Explanation :

• All methods have the same name (sum), but different parameter types.
• Method overloading ensures the correct method is called based on argument types.
• The sum(char x, char y) method adds ASCII values of characters.

Output :

Sum of two integers: 30
Sum of two doubles: 10.0
Sum of two floats: 6.0
Sum of two longs: 300000
Sum of two characters (ASCII values): 131

Read More : Methods in Java with Program Example

If you want to learn more about Method Overloading then click here