Overloading Methods
B.Bhuvaneswaran
Assistant Professor (SS)
Department of Computer Science & Engineering
Rajalakshmi Engineering College
Thandalam
Chennai 602 105
bhuvaneswaran@rajalakshmi.edu.in
Overloading Methods
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
B.Bhuvaneswaran / AP (SS) / CSE / REC
Output
No parameters
a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
B.Bhuvaneswaran / AP (SS) / CSE / REC
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
When an overloaded method is called,
Java looks for a match between the
arguments used to call the method and
the methods parameters.
However, this match need not always be
exact.
In some cases, Javas automatic type
conversions can play a role in overload
resolution.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
B.Bhuvaneswaran / AP (SS) / CSE / REC
Output
No parameters
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 123.2
B.Bhuvaneswaran / AP (SS) / CSE / REC
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Method overloading supports
polymorphism because it is one way that
Java implements the one interface,
multiple methods paradigm.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Overloading Constructors
In addition to overloading normal
methods, you can also overload
constructor methods.
In fact, for most real-world classes that
you create, overloaded constructors will
be the norm, not the exception.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Example
class Box {
double width;
double height;
double depth;
// This is the constructor for Box.
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// compute and return volume
double volume() {
return width * height * depth;
}
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
B.Bhuvaneswaran / AP (SS) / CSE / REC
B.Bhuvaneswaran / AP (SS) / CSE / REC
Output
Volume of mybox1 is 3000.0
Volume of mybox2 is 1.0
Volume of mycube is 343.0
B.Bhuvaneswaran / AP (SS) / CSE / REC
Using Objects as Parameters
It is both correct and common to pass
objects to methods.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
// Objects may be passed to methods.
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// return true if o is equal to the invoking object
boolean equals(Test o) {
if(o.a == a && o.b == b) return true;
else return false;
}
class PassOb {
public static void main(String args[]) {
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));
System.out.println("ob1 == ob3: " + ob1.equals(ob3));
B.Bhuvaneswaran / AP (SS) / CSE / REC
Output
ob1 == ob2: true
ob1 == ob3: false
B.Bhuvaneswaran / AP (SS) / CSE / REC
The equals( ) method inside Test compares two
objects for equality and returns the result.
That is, it compares the invoking object with the
one that it is passed.
If they contain the same values, then the method
returns true. Otherwise, it returns false.
Notice that the parameter o in equals( ) specifies
Test as its type.
Although Test is a class type created by the
program, it is used in just the same way as
Javas built-in types.
B.Bhuvaneswaran / AP (SS) / CSE / REC
One of the most common uses of object
parameters involves constructors.
Frequently, you will want to construct a
new object so that it is initially the same
as some existing object.
To do this, you must define a constructor
that takes an object of its class as a
parameter.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
B.Bhuvaneswaran / AP (SS) / CSE / REC
B.Bhuvaneswaran / AP (SS) / CSE / REC
B.Bhuvaneswaran / AP (SS) / CSE / REC
References
Herbert Schildt, Java The Complete
Reference, 8th Edition, Oracle Press,
2011.
B.Bhuvaneswaran / AP (SS) / CSE / REC
B.Bhuvaneswaran / AP (SS) / CSE / REC
