| << Chapter < Page | Chapter >> Page > |
The class named B defines a method named m() . The behavior of the method is simply to display a message each time it is called.
The class named C
Listing 3 contains the definition of the class named C , which also extends Object .
| Listing 3 . Definition of the class named C. |
|---|
class C extends Object{
//this class is empty}//end class C |
The class named C is also empty. It was included in this example as a sibling class for the class named A . Stated differently, it was included as a class that is not in the ancestral line of the class named B .
The driver class
Listing 4 shows the beginning of the driver class named Poly02 .
| Listing 4 . Beginning of the class named Poly02. |
|---|
public class Poly02{
public static void main(String[]args){
Object var = new B(); |
An object of the class named B
The code in Listing 4 instantiates an object of the class B and assigns the object's reference to a reference variable of type Object .
(It is important to note that the reference to the object of type B was not assigned to a reference variable of type B . Instead, it was assigned to a reference variable of type Object .)
This assignment is allowable because Object is a superclass of B . In other words, the reference to the object of the class B is assignment compatible with a reference variable of the type Object .
Automatic type conversion
In this case, the reference of type B is automatically converted to type Object and assigned to the reference variable of type Object . (Note that the use of a cast operator was not required in this assignment.)
Only part of the story
However, assignment compatibility is only part of the story. The simple fact that a reference is assignment compatible with a reference variable of a given type says nothing about what can be done with the reference after it is assigned to the reference variable.
An illegal operation
For example, in this case, the reference variable that was automatically converted to type Object cannot be used directly to call the method named m() on the object of type B . This is indicated in Listing 5 .
| Listing 5 . An illegal operation. |
|---|
//var.m(); |
An attempt to call the method named m() on the reference variable of type Object in Listing 5 resulted in a compiler error. It was necessary to convert the statement into a comment in order to get the program to compile successfully.
An important rule
In order to use a reference of a class type to call a method, the method must be defined at or above that class in the class hierarchy.
This case violates the rule
In this case, the method named m() is defined in the class named B , which is two levels down from the class named Object .
When the reference to the object of the class B was assigned to the reference variable of type Object , the type of the reference was automatically converted to type Object .
Therefore, because the reference is of type Object , it cannot be used directly to call the method named m() .
The solution is a downcast
In this case, the solution to the problem is a downcast. The code in Listing 6 shows an attempt to solve the problem by casting the reference down the hierarchy to type A .
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|