| << Chapter < Page | Chapter >> Page > |
This output confirms that each overloaded version of the method is properly selected for execution based on the matching of method parameters to the formal argument list of each method.
Previous modules introduced overloading and overriding methods. This module concentrates on the use of method overloading to achieve compile-time polymorphism .
All classes in Java form a hierarchy with a class named Object at the root of the hierarchy. Thus, every class in Java is a direct or indirect subclass of the class named Object .
If a new class doesn't explicitly extend some other class, it will, by default, automatically extend the class named Object .
The Object class defines default versions of eleven different methods. These methods are inherited into all other classes, and some (those not declared final ) may be overridden to make their behavior more appropriate for objects instantiated from the new class.
Overloaded methods have the same name and different formal argument lists. They may or may not have the same return type.
Three of the eleven methods defined in the class named Object are overloaded versions of the method name wait . One version takes no parameters. A second version takes a single parameter of type long . The third version takes two parameters, one of type long , and one of type int .
The word polymorphism means something like one name, many forms . Polymorphism manifests itself in Java in the form of multiple methods having the same name.
Polymorphism manifests itself in three distinct forms in Java:
This module concentrates on method overloading , sometimes referred to as compile-time polymorphism . This form of polymorphism is distinguished by the fact that the compiler selects a specific method from two or more overloaded methods on the basis of the types and the number of parameters passed to the method when it is called. The selection is made when the program is compiled (rather than being made later when the program is run) .
Overloaded methods may all be defined in the same class, or may be defined in different classes as long as those classes have a superclass-subclass relationship in the class hierarchy.
The sample program in this module illustrates three overloaded versions of the same method name with two of the versions being defined in a single class, and the other version being defined in the superclass of that class.
The next module in this collection teaches you about assignment compatibility, type conversion, and casting for both primitive and reference types.
It also teaches you about the relationship between reference types, method calls, and the location in the class hierarchy where a method is defined.
This section contains a variety of miscellaneous information.
Financial : Although the Connexions site makes it possible for you to download a PDF file for thismodule at no charge, and also makes it possible for you to purchase a pre-printed version of the PDF file, you should beaware that some of the HTML elements in this module may not translate well into PDF.
I also want you to know that, I receive no financial compensation from the Connexions website even if you purchase the PDF version of the module.
In the past, unknown individuals have misappropriated copies of my modules from cnx.org, converted them to Kindle books, andplaced them for sale on Amazon.com showing me as the author. I receive no compensation for those sales and don't know who doesreceive compensation. If you purchase such a book, please be aware that it is a bootleg copy of a module that is freelyavailable on cnx.org.
Affiliation : I am a professor of Computer Information Technology at Austin Community College in Austin, TX.
A complete listing of the program is shown in Listing 4 below.
| Listing 4 . Complete program listing. |
|---|
/*File Poly01.java
Copyright 2002, R.G.BaldwinProgram output is:
m()m(int x)
m(String y)**************************************/
class A extends Object{public void m(){
System.out.println("m()");}//end method m()
}//end class A//===================================//
class B extends A{public void m(int x){
System.out.println("m(int x)");}//end method m(int x)
//---------------------------------//public void m(String y){System.out.println("m(String y)");
}//end method m(String y)}//end class B
//===================================//public class Poly01{
public static void main(String[]args){
B var = new B();var.m();
var.m(3);var.m("String");
}//end main}//end class Poly01 |
-end-
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|