1
0

In Java, it is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations or parameter type or number of parameters are different. The concept is similar to constructor overloading discussed in the previous section. When two or more methods have the same name, the methods are said to be overloaded, and the process is referred to as method overloading.

class Rectangle
{
double length;
double width;
void data(double a, double b)
{
length=a;
width=b;
}
void data(double a) // overload data() for a single parameter
{
length=a;
width=12;
}
void show()
{
System.out.println("Length of the Rectangle = "+length);
System.out.println("Width of the Rectangle = "+width);
System.out.println("Area of the Rectangle = "+length*width);
}
}
class ClassReturn
{
public static void main(String args[])
{
double result;
Rectangle Rect1=new Rectangle();
Rectangle Rect2=new Rectangle();
Rect1.data(20, 30); // call to void data(double a, double b);
Rect1.show();
Rect2.data(20); // call to void data(double a);
Rect2.show();
}
}

Output:

Length of the Rectangle = 20.0
Width of the Rectangle = 30.0
Area of the Rectangle = 600.0
Length of the Rectangle = 20.0
Width of the Rectangle = 12.0
Area of the Rectangle = 240.0

As you can see, data() is overloaded two times. The first version takes two parameters the second takes one parameter. Note that return types do not play any role in method overloading. Overloaded methods must differ in the number or type of arguments.

Note-1: When an overloaded method is called, Java looks for a match between the arguments used to call the method and the method’s parameters. However, this match need not always be exact. In some cases, Java’s automatic type conversions can play a role in overload resolution. For example, consider the following program:

class Rectangle
{
double length;
double width;
void data()
{
length=20;
width=10;
}
void data(double a, double b) //overload data() for a double parameter
{
length=a;
width=b;
}
void data(double a) // overload data() for a single parameter
{
length=a;
width=12;
}
void show()
{
System.out.println("Length of the Rectangle = "+length);
System.out.println("Width of the Rectangle = "+width);
System.out.println("Area of the Rectangle = "+length*width);
}
}
class ClassReturn
{
public static void main(String args[])
{
int var=20;
// void result;
Rectangle Rect1=new Rectangle();
Rectangle Rect2=new Rectangle();
Rectangle Rect3=new Rectangle();
Rect1.data();
Rect1.show();
result=Rect2.data(12,5);
System.out.println("Area of the Rectangle="+result);
Rect3.data(var);
Rect3.show();
}
}

Output:

Length of the Rectangle = 20
Width of the Rectangle = 10
Area of the Rectangle = 200
Length of the Rectangle = 12
Width of the Rectangle = 5
Area of the Rectangle = 60
Length of the Rectangle = 20
Width of the Rectangle = 12
Area of the Rectangle = 240

As you can see, this version of the rectangle does not define data(int). Therefore, when data() is called with an integer argument inside Overload, no matching method is found. However, Java can automatically convert an integer into a double, and this conversion can be used to resolve the call. Therefore, after data(int) is not found, Java elevates var to double and then calls data(double). Of course, if data(int) had been defined, it would have been called instead. Java will employ its automatic type conversions only if no exact match is found