Types of polymorphism in java – Runtime Polymorphism, Compile time Polymorphism

As we all know what is polymorphism in java, now its time to dig a bit deeper into it. There are two types of Polymorphism which is possible in Java, Runtime Polymorphism (Dynamic Binding) and Compile time Polymorphism (Static Binding). Lets take a look into it one by one.

Runtime Polymorphism(Dynamic Binding)

Method Overriding in Java is the best example for Runtime Polymorphism. In this type of Polymorphism the Parent class reference can hold object of Parent class or any sub class(Child class) of Parent. This technique is called as Dynamic Method Dispatch

//Assigning Parent class Object to Parent class reference
Parent p = new Parent();
//Assigning Child class Object to Parent class reference
Parent p = new Child();

Dynamic Method Dispatch is a technique in which the overriden method to call is resolved at the run-time rather than at compile time. In this technique we will assigning the Child object to the Parent class reference. Lets look into the below code

class Parent 
{
    public void display(String name)
    {
        System.out.println("Welcome to Parent Class \""+name+"\"");
    }
    public void disp()
    {
        System.out.println("disp() method of Parent class");
    }
}
public class Child extends Parent
{
    public void display(String name)
    {
        System.out.println("Welcome to Child Class \""+name+"\"");
    }
    public void show()
    {
        System.out.println("show() method of Child class");
    }
    public static void main(String args[])
    {
        //Assign Child Object to Parent class reference
        Parent pp = new Child();
        pp.display("JIP");
     }
}

Here we have assigned Child class object (new Child()) to Parent class reference (Parent pp) and now come the question which of the display() method will be called. Here the new Child() object is resolved in the run-time the display() method of the child class will be called and hence the output will be

Welcome to Child Class "JIP"

What if the child class didn’t override the parent class method?

In the above example of Dynamic Method Dispatch the child class has overriden the parent class display() method and hence the child class display() method is called, now the question is what will happen if the child class didn’t override the parent class method.

class Parent 
{
    public void display(String name)
    {
        System.out.println("Welcome to Parent Class \""+name+"\"");
    }
    public void disp()
    {
        System.out.println("disp() method of Parent class");
    }
}
public class Child extends Parent
{
    public void show()
    {
        System.out.println("show() method of Child class");
    }
    public static void main(String args[])
    {
        //Assign Child object to Parent class reference
        Parent pp = new Child();
        pp.display("JIP");
     }
}

When the Child class didn’t override the Parent class method as in the above case then the display() method of the Parent will be called.

Welcome to Parent Class "JIP"

Can the Child class method be called in the Dynamic Method Dispatch?

The answer is NO, Lets try to call the show method of the Child class

class Parent 
{
    public void display(String name)
    {
        System.out.println("Welcome to Parent Class \""+name+"\"");
    }
    public void disp()
    {
        System.out.println("disp() method of Parent class");
    }
}
public class Child extends Parent
{
    public void display(String name)
    {
        System.out.println("Welcome to Child Class \""+name+"\"");
    }
    public void show()
    {
         System.out.println("show() method of child class");
    }
    public static void main(String args[])
    {
        //Assign Child refernce to Parent class
        Parent pp = new Child();
        pp.show();
     }
}

When you run the above code then we will get the below compile time exception “The method show() is undefined for the type Parent”. In Dynamic Method Dispatch

• The Overridden methods of the Child class can be called.
• Non-Overridden methods of the Parent class can be called.
• Child class methods cannot be called.

Compile time Polymorphism (Static Binding)

Method overloading in Java is the best example for Compile time Polymorphism. In Complie time Polymorphism the control flow is decided during the compile time itself.  Simply we can say that a class can have more than one method with a same name but difference in the parameters. Lets look into the below code for the better understanding.

class A
{
	public void disp()
	{
		System.out.println("Inside First disp method");
	}

	public void disp(String val)
	{
		System.out.println("Inside Second disp method, value is: "+val);
	}

	public void disp(String val1,String val2)
	{
		System.out.println("Inside Third disp method, values are : "+val1+","+val2);
	}
}
public class B
{
	public static void main (String args[])
	{
		A a = new A();
		a.disp(); //Calls the first disp method
		a.disp("Java Interview"); //Calls the second disp method
		a.disp("JavaInterview", "Point"); //Calls the third disp method
	}

}

Output

Inside First disp method
Inside Second disp method, value is: Java Interview
Inside Third disp method, values are : JavaInterview,Point

As we can see in the above example class A have 3 disp() methods but the number and type of parameter differs. In this scenario the compiler will be able to figure out which disp() method to call during the compile time itself based on number and type of parameter and hence it is called as Compile time Polymorphism.