Method Overloading in Java with examples

Method Overloading is a feature that allows a class to have multiple methods with the same name but with different number, sequence or type of parameters. In short multiple methods with same name but with different signatures. For example the signature of method add(int a, int b) having two int parameters is different from signature of method add(int a, int b, int c) having three int parameters.

This is one of the most popular OOP feature in java, there are several cases where we need more than one methods with same name. For example let’s say we are writing a java program to find the sum of input numbers, we need different variants of add method based on the user inputs such as add(int, int), add(float, float) etc.

It is similar to constructor overloading in Java, that allows a class to have more than one constructor with different argument lists.

Three ways to overload a method

In order to overload a method, the parameter list of the methods must differ in either of these:
1. Number of parameters.
For example: This is a valid case of overloading

add(int, int)
add(int, int, int)

2. Data type of parameters.
For example:

add(int, int)
add(int, float)

3. Sequence of Data type of parameters.
For example:

add(int, float)
add(float, int)

Invalid case of method overloading:
Parameters list doesn’t mean the return type of the method, for example if two methods have same name, same parameters and have different return type, then this is not a valid method overloading example. This will throw a compilation error.

int add(int, int)
float add(int, int)

Method overloading is an example of Static Polymorphism. We will discuss polymorphism and types of it in a separate tutorial.

Points to Note:
1. Static Polymorphism is also known as compile time binding or early binding.
2. Static binding happens at compile time. Method overloading is an example of static binding where binding of method call to its definition happens at Compile time.

Argument list vs parameter list: Argument list and parameter list are same but they are used in different context, when we declare a method, the parameters are called parameter list, while calling the method the argument we pass are called argument list.

Method Overloading examples

As discussed in the beginning of this guide, method overloading is done by declaring same method with different signatures. Let’s see some examples:

Example 1: Overloading – Different Number of parameters in signature

This example shows how method overloading is done by having different number of parameters. In this example, we have two methods with the same name add, but number of parameters are different. First variation of add() method has two int parameters, while the second variation of method add() has two int parameters.

class DisplayOverloading
{
  //adding two integer numbers
  int add(int a, int b)
  {
    int sum = a+b;
    return sum;
  }
  //adding three integer numbers
  int add(int a, int b, int c)
  {
    int sum = a+b+c;
    return sum;
  }
}
class JavaExample
{
  public static void main(String args[])
  {
    DisplayOverloading obj = new DisplayOverloading();
    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
  }
}

Output:

30
60

Example 2: Overloading – Data type of parameters are different

In this example, we are overloading the method add() based on the data type of parameters. We have two methods with the name add() but the type of parameters are different. The first variation of add() has two int params while the second variation of method add() has two float params.

class DisplayOverloading2
{
  //two int parameters
  public int add(int a, int b)
  {
    int sum = a+b;
    return sum;
  }
  //two float parameters
  public float add(float a, float b)
  {
    float sum = a+b;
    return sum;
  }
}

class JavaExample
{
  public static void main(String args[])
  {
    DisplayOverloading2 obj = new DisplayOverloading2();
    //This will call the method add with two int params
    System.out.println(obj.add(5, 15));

    //This will call the method add with two float params
    System.out.println(obj.add(5.5f, 2.5f));
  }
}

Output:

20
8.0

Example3: Overloading – Sequence of data type of parameters is different

In this example, the both the variations of method add() has same number of parameters but the sequence of data type of parameters is different.

First variation has (int, float) parameters and the second variation has (float, int) parameters. Since the sequence is different, the method can be overloaded without any issues.

class DisplayOverloading3
{
  public float add(int a, float b)
  {
    System.out.println("Method with (int, float) param list.");
    return a+b;
  }
  public float add(float a, int b)
  {
    System.out.println("Method with (float, int) param list.");
    return a+b;
  }
}
class JavaExample
{
  public static void main(String args[])
  {
    DisplayOverloading3 obj = new DisplayOverloading3();

    // This will call the method where first parameter is int
    // and the second parameter is float
    System.out.println(obj.add(10, 10.5f));

    // This will call the method where first parameter is float
    // and the second parameter is int
    System.out.println(obj.add(1.5f, 1));
  }
}

Output:

Method Overloading and Type Promotion

When a data type of smaller size is promoted to the data type of bigger size than this is called type promotion, for example: byte data type can be promoted to short, a short data type can be promoted to int, long, double etc.

What it has to do with method overloading?
Well, it is very important to understand type promotion else you will think that the program will throw compilation error but in fact that program will run fine because of type promotion.
Lets take an example to see what I am talking here:

class JavaExample{
  void disp(int a, double b){
    System.out.println("Method A");
  }
  void disp(int a, double b, double c){
    System.out.println("Method B");
  }
  public static void main(String args[]){
    JavaExample obj = new JavaExample();
    /* I am passing float value as a second argument but
     * it got promoted to the type double, because there
     * wasn't any method having arg list as (int, float)
     */
    obj.disp(100, 20.67f);
  }
}

Output:

Method A

As you can see in the above output, I had passed the second argument as float while calling the disp() method, however it got promoted to the double type as there wasn’t any method with argument list as (int, float)

But this type promotion doesn’t always happen, lets see another example:

class JavaExample{
  void disp(int a, double b){
    System.out.println("Method A");
  }
  void disp(int a, double b, double c){
    System.out.println("Method B");
  }
  void disp(int a, float b){
    System.out.println("Method C");
  }
  public static void main(String args[]){
    JavaExample obj = new JavaExample();
    /* This time promotion won't happen as there is
     * a method with parameter list as (int, float)
     */
    obj.disp(100, 20.67f);
  }
}

Output:

Method C

As you see that this time type promotion didn’t happen because there was a method with matching argument type.

Type Promotion table:

The data type on the left side can be promoted to any of the data type present at the right side.

byte → short → int → long → double
short → int → long → float → double
int → long → float → double
float → double
long → float → double
char → int → long → float → double

This can be represented as a diagram like this:

Lets see few Valid/invalid cases of method overloading

Case 1:

int mymethod(int a, int b, float c)
int mymethod(int var1, int var2, float var3)

Result: Compile time error. Argument lists are exactly same. Both methods are having same number, data types and same sequence of data types.

Case 2:

int mymethod(int a, int b)
int mymethod(float var1, float var2)

Result: Perfectly fine. Valid case of overloading. Here, data types of arguments are different.

Case 3:

int mymethod(int a, int b)
int mymethod(int num)

Result: Perfectly fine. Valid case of overloading. Here number of arguments are different.

Case 4:

float mymethod(int a, float b)
float mymethod(float var1, int var2)

Result: Perfectly fine. Valid case of overloading. Sequence of the data types of parameters are different, first method is having (int, float) and second is having (float, int).

Case 5:

int mymethod(int a, int b)
float mymethod(int var1, int var2)

Result: Compile time error. Argument lists are exactly same. Even though return type of methods are different, it is not a valid case. Since return type of method doesn’t matter while overloading a method.

Guess the answers before checking it at the end of programs:
Question 1 – return type, method name and argument list same.

class Demo
{
   public int myMethod(int num1, int num2)
   { 
       System.out.println("First myMethod of class Demo");
       return num1+num2;
   }
   public int myMethod(int var1, int var2)
   {
       System.out.println("Second myMethod of class Demo");
       return var1-var2;
   }
}
class Sample4
{
   public static void main(String args[])
   {
       Demo obj1= new Demo();
       obj1.myMethod(10,10);
       obj1.myMethod(20,12);
   }
}

Answer:
It will throw a compilation error: More than one method with same name and argument list cannot be defined in a same class.

Question 2 – return type is different. Method name & argument list same.

class Demo2
{
   public double myMethod(int num1, int num2)
   {
      System.out.println("First myMethod of class Demo");
      return num1+num2;
   }
   public int myMethod(int var1, int var2)
   {
      System.out.println("Second myMethod of class Demo");
      return var1-var2;
   }
}
class Sample5
{
   public static void main(String args[])
   {
      Demo2 obj2= new Demo2();
      obj2.myMethod(10,10);
      obj2.myMethod(20,12);
   }
}

Answer:
It will throw a compilation error: More than one method with same name and argument list cannot be given in a class even though their return type is different. Method return type doesn’t matter in case of overloading.

Advantages of Method Overloading

• Readability: It is not possible to have two methods with same name unless you are doing method overloading. Constantly looking for a unique method name for a similar task is quite a headache. It also impact the readability of the code. Method overloading solves this problem and improves readability of the code.
• Structured Program: Improves the structure of overall program. Promotes the use of methods which reduces the lines of code significantly.
• Reusability: Methods promotes reusability. Instead of writing same code again and again, define the code in method and call it whenever required.
• Reduces code size: It reduces the number of lines of the code because of the improved program structure.

Method Overloading vs Overriding in Java

In Method Overloading , we have multiple methods with same name but with different signatures. In method Overriding, we define the same method with the same signature in the child class and change the body of the method. The differences are discussed in detail here.

FAQ

1. Can we Overload a static method?

Yes we can overload a static method. However a non-static method cannot be overriden by a static method and vice versa. Refer this guide: Can static methods be overloaded or overriden in Java?

2. Can we overload main method of Java?

Yes, we can overload a main method. See the following example:

public class JavaExample {
  //Overloading main() methods
  //Here we have three variations of main() method
  public static void main(String[] args)
  {
    System.out.println("Main Method: String[] args");

    //calling main with one string param
    JavaExample.main("AA");

    //calling main with two string param
    JavaExample.main("BB", "CC");
  }

  // Overloaded main methods
  public static void main(String arg)
  {
    System.out.println("Main Method: String arg");
    System.out.println(arg);
  }
  public static void main(String arg, String arg2)
  {
    System.out.println("Main Method: String arg, String arg2");
    System.out.println(arg+" "+arg2);
  }
}

Output:

3. Is there a concept of Operator overloading in Java?

No. Java doesn’t allow operator overloading. C++ however allows it. This is discussed here.

Recommended Posts

• Overloading with Auto-boxing and Widening in Java
• Overloading a method with Varargs Parameter
• Method Overloading – Passing Null Values