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 implements
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.
SIMPLE PROGRAM SHOWING METHOD OVERLOADING:// Demonstrate method overloading.
class OverloadMethod {
void check() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void check(int m) {
System.out.println("m: " + m);
}
// Overload test for two integer parameters.
void check(int m, int n) {
System.out.println("m and n: " + m + " " + n);
}
// overload test for a double parameter
void check(double m) {
System.out.println("Inside check(double) m: " + m);
}
}
class Overload {
public static void main(String args[]) {
OverloadMethod ab = new OverloadMethod();
int a = 88;
ab.check();
ab.check(12, 22);
ab.test(a); // this will invoke test(double)
ab.test(2.2); // this will invoke test(double)
}
}
This program generates the following output:
No parameters
m and n: 10 20
m: 88
Inside check(double) m: 2.2
Do you like this article? Share It!
0 comments to "METHOD OVERLOADING"
Post a Comment