| << Chapter < Page | Chapter >> Page > |
C. OK OK
Type conversion
This program illustrates type conversion up the inheritance hierarchy, both with and without a cast.
Store object's reference as type Object
The following fragment instantiates a new object of the class named MyClassA , and stores that object's reference in a reference variable of type Object . This demonstrates that you can store an object's reference in a reference variablewhose type is a superclass of the class from which the object was instantiated, with no cast required.
class Worker{
void doIt(){Object refA = new MyClassA(); Cast object's reference to type Object
The code in the next fragment instantiates an object of the class named MyClassB , and stores the object's reference in a reference variable of type Object , after first casting the reference to type Object . This, and the previous fragment demonstrate that while it is allowable to cast a reference to thesuperclass type before storing it in a superclass reference variable, such a cast is not required.
Object refB =
(Object)(new MyClassB()); Type conversion and assignment compatibility
This is part of a larger overall topic commonly referred to as type conversion. It also touches the fringes of something that is commonly referredto as assignment-compatibility.
Automatic type conversions
Some kinds of type conversions happen automatically. For example, you can assign a value of type byte to a variable of type int and the type conversion will take place automatically.
Cast is required for narrowing conversions
However, if you attempt to assign a value of type int to a variable of type byte , the assignment will not take place automatically. Rather, the compiler requires you to provide a cast to confirm that you accept responsibility for theconversion, which in the case of int to byte could result in the corruption of data.
Automatic conversions up the inheritance hierarchy
When working with objects, type conversion takes place automatically for conversions toward the root of the inheritance hierarchy.Therefore, conversion from any class type to type Object happen automatically. However, conversions in the direction away from the root require a cast.
(Conversion from any class type to any superclass of that class also happens automatically.)
Polymorphic behavior
The code in the next fragment uses polymorphic behavior to display the contents of the two String objects.
System.out.print(refA);
System.out.print(refB); No cast required
This works without the use of a cast because the print method calls the toString method on any object's reference that it receives as an incoming parameter. The toString method is defined in the Object class, and overridden in the String class. Polymorphic behavior dictates that in such a situation, the version of the method belonging to the object will be called regardless of thetype of the reference variable holding the reference to the object.
When would a cast be required?
Had the program attempted to call a method on the reference that is not defined in the Object , class, it would have been necessary to cast the reference down the inheritance hierarchy in order to successfully call the method.
-end-
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|