Not runtime polymorphic behavior
Just for the record, the above invocation of the method does not constitute runtime polymorphism (in my opinion) . I included that invocation of the method to serve as a backdrop for what follows.
This is runtime polymorphic behavior
However, the call to the method in Listing 4 does constitute runtime polymorphism.
Listing 4 . This is runtime polymorphic behavior.
//Following will also compile
// and run due to polymorphic// behavior.
((A)var).m();
The statement in Listing 4 casts the reference down to type A and calls the method named m on that reference.
The method output
Here is the punch line. Not only does the statement in Listing 4 compile and run successfully, it produces the following output, (which is exactly the same output as before) :
m in class B
The same method was executed in both cases
Very important
It is very important to note that this output, (produced by casting the reference variable to type A instead of type B ) , is exactly the same as that produced by the earlier call to the method when thereference was cast to type B . This means that the same version of the method was executed in both cases.
This confirms that even though the type of the reference was converted to type A , (rather than type Object or type B ) , the overridden version of the method defined in class B was actually executed.
This is runtime polymorphic behavior in a nutshell.
The version of the method that was executed was based on the actual type of the object, B , and not on the type of the reference, A . This is an extremely powerful and useful concept.
Another invocation of the method
Now take a look at the statement in Listing 5 . Will this statement compile and execute successfully? If so, which version of the method will be executed?
Listing 5 . A failed attempt.
//Following will not compile
//var.m();
(That was easy. The answer to the question is given in Listing 5 ) .
Compiler error
The code in Listing 5 attempts, unsuccessfully, to call the method named m using the reference variable named var , which is of type Object . The result is a compiler error, which reads something like the following:
error CS0117: 'object' does not contain a definition for 'm'
Some important rules
The Object class does not define a method named m . Therefore, the overridden method named m in the class named B is not an overridden version of a method that is defined in the class named Object .
Necessary, but not sufficient
Runtime polymorphism based on class inheritance requires that the type of the reference variable be a superclass of the class from which the object (on which the method will be called) is instantiated.