Answers for "Run time polymorphism"

Compile time polymorphism

// In this program, we will see how multiple functions are created with the same name, 
// but the compiler decides which function to call easily at the compile time itself.
class CompileTimePolymorphism{
   // 1st method with name add
   public int add(int x, int y){ 
   return x+y;
   }
   // 2nd method with name add
   public int add(int x, int y, int z){
   return x+y+z;
   }
   // 3rd method with name add
   public int add(double x, int y){ 
   return (int)x+y;
   }
   // 4th method with name add
   public int add(int x, double y){ 
   return x+(int)y;
   }
}
class Test{
   public static void main(String[] args){
   CompileTimePolymorphism demo=new CompileTimePolymorphism();
   // In the below statement, the Compiler looks at the argument types and decides to call method 1
   System.out.println(demo.add(2,3));
   // Similarly, in the below statement, the compiler calls method 2
   System.out.println(demo.add(2,3,4));
   // Similarly, in the below statement, the compiler calls method 4
   System.out.println(demo.add(2,3.4));
   // Similarly, in the below statement, the compiler calls method 3
   System.out.println(demo.add(2.5,3)); 
   }
}

what is runtime polymorphism

Runtime polymorphism is a process of which take
cares the overriding method at run time
rather than compile time.
 In method overriding,
a subclass overrides a method with the same 
signature as that of in its superclass. 
During compile time, the check is made 
on the reference type. But, in the runtime,
JVM figures out the object type and would 
run the method that belongs to
that particular object.

Run time polymorphism

class base{
     public:
          void fun(){
               cout<<”base “;
          }
};
class derived: public base{
     public:
          void fun(){
               cout<<”derived ”;
          }
};
int main(){
     A *a=new B;
     a->fun();

     return 0;
}