Object Casting Java

What is casting?
Assigning one data type to another or one object to another is known as casting. Java supports two types
of casting data type casting and object casting.
Conditions of assigning objects of different classes one to another
Same class objects can be assigned one to another and it is what we have done with Officer1 class.
Subclass object can be assigned to a super class object and this casting is done implicitly. This is
known as upcasting (upwards in the hierarchy from subclass to super class).
Java does not permit to assign a super class object to a subclass object (implicitly) and still to do
so, we need explicit casting. This is known as downcasting (super class to subclass). Downcasting
requires explicit conversion.
Program explaining the above rules of Java Object Casting
class Flower
{
public void smell()
// parent class method
{
System.out.println("All flowers give smell, if you can smell");
}
}
public class Rose extends Flower
{
public void smell()
// child class method
{
System.out.println("Rose gives rosy smell");
}
public static void main(String args[])
{
Flower f = new Flower();
Rose r = new Rose();
f.smell();
// Parent class object accessing parent class method
r.smell();
// Child class object accessing child class method
f = r;
f.smell();

// assigning subclass object to super class, it is valid

// II

// r = f;
r = (Rose) f;
f.smell();

// super class to subclass, not valid

// explicit casting
// II

}
}
Output
D:\lab>javac Rose.java
D:\lab>java Rose
All flowers give smell, if you can smell
Rose gives rosy smell
Rose gives rosy smell
Rose gives rosy smell
The super class Flower includes only one method smell() and it is overridden by subclass Rose.
f.smell();
// I
r.smell();
// II
In the above two statements, nothing is new as both object are calling their own smell() methods.
Object Casting Java 1

Now Observe the following two statements.

f = r;
f.smell();
In the first statement, subclass object r is assigned (casted) to super class object f. It is a perfect
assignment accepted by JVM and casting is done implicitly. In the super class object f, the subclass object
reference (address) r exists. Calling f.smell(), f will call Rose smell() method.
From the above observation, a rule can be made as follows.
"If a subclass object is assigned to a super class object, the super class object will call subclass
overridden method". This is an important rule which leads to dynamic polymorphism.
// r = f;
// r = f;
The above statement does not compile as super class object is assigned to subclass object. To do it, we
require explicit casting.
r = (Rose) f; // explicit casting
f.smell();
// II
In the above statement, Flower object f is explicitly casted to Rose object r.
In the earlier statement f = r, the f includes Rose reference.
Now, f returns the Rose reference to Rose itself. For this reason f.smell() prints the subclass Rose
smell(). That is, r is calling its own smell().
What happens if f = r does not exist earlier. It will be a an exception (not compilation error). That is,
"before doing explicit casting, implicit casting must be done".

Object Casting Java 2