This is very important interview question. Simply Compile-time polymorphism is known as overriding and Run-time polymorphism is known as overloading. I think you may know about the differences between both of overloading and overriding. (OOP concepts)
But question is this, If someone asked why it is called compile-time polymorphism and run-time polymorphism ? Lets try to find out the answers by examples.
Overriding is called run-time polymorphism. WHY ???
Look at the following example.
//Parent class class Parent { public void eat(){ System.out.println("Parent - eat()"); } } //Child class class Child extends Parent { @Override public void eat() { System.out.println("Child - eat()"); } } public class OOPDemo { public static void main(String args[]){ Parent obj = new Child(); obj.eat(); } }
In this example I've created a parent class, child class and the main class. Then I've created a Child object by Parent reference.
Compile time
- In compile time it takes care about the Parent reference. Because objects are created in the run time.
- First it checks is there any eat() method in Parent class.
- In this example Parent class has eat() method.
- So it doesn't give any exception in the compile time and compilation will be success.
Run time
- In run time it takes care about the Child reference and it creates new Child object.
- Then it checks is there any eat() method in Child class.
- There is a eat() methods in Child also. Then this method will be called in the run time.
- It means object creation is happen at the run time by JVM and Run time is responsible to call which eat() method to call.
- That is why it is called run-time polymorphism (Dynamic polymorphism)
Overloading is called compile-time polymorphism. WHY ???
Look at the following example.
class Animal{ public void eat(){ System.out.println("Eat method"); } public void eat(int quantity){ System.out.println("Eat method with quantity"); } } public class ReferenceDemo { public static void main(String args[]){ Animal animal = new Animal(); animal.eat(); } }
In this case single class has same methods with two different parameters. As you know it is called method overloading.
Compile time
- In compile time it checks animal.eat() method in Animal class.
- No arg eat() method is there in the animal class.
- According to the parameter list it will call which method should be called.
- Then compilation is OK.
Run time
- In run time it creates same Animal type object.
- Then it checks the same thing what is did in the compile time.
- It means compile time is enough to check which method should be called.
- That is why it is called Compile time polymorphism ( Static polymorphism).
Finally
Overriding = run-time polymorphism = dynamic polymorphism
Overloading = compile-time polymorphism = static polymorphism