Overloading methods

Overloading constructors
 method overloading
• 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 are different.
• When this is the case, the methods are said to
be overloaded, and the process is referred to as
method overloading.
• Method overloading is one of the ways that Java
supports polymorphism.
• When an overloaded method is invoked, Java
uses the type and/or number of arguments as
its guide to determine which version of the
overloaded method to actually call.
• Thus, overloaded methods must differ in the
type and/or number of their parameters.
• While overloaded methods may have different
return types, the return type alone is
insufficient to distinguish two versions of a
method.
• When Java encounters a call to an overloaded
method, it simply executes the version of the
method whose parameters match the
arguments used in the call.
 LTC: Method Overloading
// Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.25);
System.out.println("Result of ob.test(123.25): " +
result);
}
}
This program generates the following output:
No parameters
a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
• test( ) is overloaded four times. The first
version takes no parameters, the second takes
one integer parameter, the third takes two
integer parameters, and the fourth takes one
double parameter.
• The fact that the fourth version of test( ) also
returns a value is of no consequence relative to
overloading, since return types do not play a
role in overload resolution.
• 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:
// Automatic type conversions apply to
overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
void test(double a) {
System.out.println("Inside test(double) a: " + a);
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
int i = 88;
ob.test();
ob.test(10, 20);
ob.test(i); // this will invoke test(double)
ob.test(123.2); // this will invoke test(double)
}
}
This program generates the following output:
No parameters
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 123.2
• this version of OverloadDemo does not define
test(int).
• Therefore, when test( ) 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 test(int) is not found, Java
elevates i to double and then calls
test(double). Of course, if test(int) had been
defined, it would have been called instead.
• Java will employ its automatic type
conversions only if no exact match is found
• When you overload a method, each version of
that method can perform any activity you
desire.
• There is no rule stating that overloaded
methods must relate to one another.
• In practice, you should only overload closely
related operations.
Overloading Constructors
• What if you simply wanted a box and did not
care (or know) what its initial dimensions
were? Or, what if you want to be able to
initialize a cube by specifying only one value
that would be used for all three dimensions?
• Fortunately, the solution to these problems is
quite easy: simply overload the Box
constructor so that it handles the situations
just described.
 LTC: Overloading Constructors
/* Here, Box defines three constructors to
initialize the dimensions of a box various ways.
*/
class Box {
double width;
double height;
double depth;
// constructor used when all dimensions
specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions
specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
class OverloadCons {
public static void main(String args[]) {
// create boxes using the various constructors
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mycube = new Box(7);
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of mycube is " + vol);
}
}
• The output produced by this program is
shown here:
Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0
Volume of mycube is 343.0
• As you can see, the proper overloaded
constructor is called based upon the
parameters specified when new is executed.

End the session