| << Chapter < Page | Chapter >> Page > |
| Listing 6 . A new object of type A. |
|---|
var = new A();
((A)var).m(); |
A new object of type A
The code in Listing 6 instantiates a new object of the class named A , and stores the object's reference in the original reference variable named var of type Object .
(As a side note, this overwrites the previous contents of the reference variable with a new reference and causes the object whose reference was previously stored there to become eligible for garbage collection.)
Downcast and call the method
Then the code in Listing 6 casts the reference down to type A , (the type of the object to which the reference refers) , and calls the method named m() on the downcast reference.
The output
As you would probably predict, this produces the following output on the computer screen:
m in class A
In this case, the version of the method defined in the class named A , (not the version defined in B ) was executed.
Not polymorphic behavior
In my view, this is not polymorphic behavior (at least it isn't a very useful form of polymorphic behavior) . This code simply converts the type of the reference from type Object to the type of the class from which the object was instantiated, and calls one of its methods. Nothing special takes place regarding a selection among different versions of the method.
Some authors may disagree
While some authors might argue that this is technically runtime polymorphic behavior, in my view at least, it does not illustrate the real benefits of runtime polymorphic behavior. The benefits of runtime polymorphic behavior generally accrue when the actual type of the object is a subclass of the type of the reference variable containing the reference to the object.
Once again, what is runtime polymorphism?
As I have discussed in this module, runtime polymorphic behavior based on class inheritance occurs when
More than you ever wanted to hear
And that is probably more than you ever wanted to hear about runtime polymorphism based on class inheritance.
A future module will discuss runtime polymorphism based on the Java interface. From a practical viewpoint, you will find the rules to be similar but somewhat different in the case of the Java interface.
A very important concept
As an example of the importance of runtime polymorphism in Java, the entire event-driven graphical user interface structure of Java is based on runtime polymorphism involving the Java interface.
Polymorphism manifests itself in Java in the form of multiple methods having the same name.
From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:
This module discusses method overriding through class inheritance.
With runtime polymorphism based on method overriding, the decision as to which version of a method will be executed is based on the actual type of object whose reference is stored in the reference variable, and not on the type of the reference variable on which the method is called.
The decision as to which version of the method to call cannot be made at compile time. That decision must be deferred and made at runtime. This is sometimes referred to as late binding.
This is illustrated in the sample program discussed in this module.
In the next module, I will continue my discussion of the implementation of polymorphism using method overriding through class inheritance, and I will concentrate on a special case in that category.
Specifically, I will discuss the use of the Object class as a completely generic type for storing references to objects of subclass types, and explain how that results in a very useful form of runtime polymorphism.
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 7 below.
| Listing 7 . Listing 7 : Complete program listing. |
|---|
/*File Poly03.java
Copyright 2002, R.G.BaldwinThis program illustrates downcasting
and polymorphic behaviorProgram output is:m in class B
m in class Bm in class A
**************************************/class A extends Object{
public void m(){System.out.println("m in class A");
}//end method m()}//end class A
//===================================//class B extends A{
public void m(){System.out.println("m in class B");
}//end method m()}//end class B
//===================================//public class Poly03{
public static void main(String[]args){
Object var = new B();//Following will compile and run
((B)var).m();//Following will also compile
// and run due to polymorphic// behavior.
((A)var).m();//Following will not compile
//var.m();//Instantiate obj of class A
var = new A();//Call the method on it
((A)var).m();}//end main
}//end class Poly03 |
-end-
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|