Explain run-time polymorphism
Overridden methods in Java are similar to virtual functions in C++ language.
Dynamic method dispatch is the mechanism by which a call to an overridden method is
resolved at run time, rather than compile time.
Dynamic method dispatch is important because this is how Java implements run-time
polymorphism.
A superclass reference variable can refer to a subclass object. Java uses this fact to resolve
calls to overridden methods at run time.
When an overridden method is called through a superclass reference, Java determines which
version of that method to execute based upon the type of the object being referred to at the
time the call occurs.
Example :
class A
{
void callme()
{
System.out.println("Inside A's");
}
}
class B extends A
{
// override callme()
void callme()
{
System.out.println("Inside B's");
}
}
class C extends A
{
// override callme()
void callme()
{
System.out.println("Inside C's");
}
}
class Dispatch
{
public static void main(String args[])
{
A a = new A(); // object of type A
B b = new B(); // object of type B
C c = new C(); // object of type C
A r; // obtain a reference of type A
r = a; // r refers to an A object
r.callme(); // calls A's version of callme
r = b; // r refers to a B object
r.callme(); // calls B's version of callmeE
JAVAr = c; // r refers to a C object
r.callme(); // calls C's version of callme
}
}
Output :
Inside A’s
Inside B’s
Inside C’s
This program creates one superclass called A and two subclasses of it, called B and C.
Subclasses B and C override callme( ) declared in A. Inside the main( ) method, objects of type
A, B, and C are declared. Also, a reference of type A, called r, is declared. The program then
assigns a reference to each type of object to r and uses that reference to invoke callme( ). As the
output shows, the version of callme( ) executed is determined by the type of object being referred
to at the time of the call.
Comments
Post a Comment