Static and Dynamic Polymorphism in OOP

 

There are two types of Polymorphism.
1. Static Polymorphism.
2. Dynamic Polymorphism.

Static polymorphism is achieved through method overloading. Method overloading means there are several methods present in a class having the same name but different types/order/number of parameters.
At compile time, compiler knows which method to invoke by checking the method signatures.  So, this is called compile time polymorphism or static binding. The concept will be clear from the following example:

class Adder{
    static int add(int a, int b){
        return a + b;
    }
    static int add(int a, int b, int c){
        return a + b + c;
    }
}


class Main{
    public static void main(String[] args){
        System.out.println(Adder.add(11, 11);
        System.out.println(Adder.add(11, 11, 11);
    }
}

Dynamic Polymorphism:

Suppose a sub class overrides a particular method of the super class. Let’s say, in the program, we create an object of the subclass and assign it to the super class reference. Now, if we call the overridden method on the super class reference then the sub class version of the method will be called.
Have a look at the following example.

 

class Vehicle
{
  public void move ()
  {
    System.out.println ("Vehicle can move!");
  }
}

class MotorBike extends Vehicle
{
  public void move ()
  {
    System.out.println ("Motorbike can move and accelarate too!");
  }
}



public class Main
{
  public static void main (String[]args)
  {
    Vehicle rickshaw = new Vehicle ();
    Vehicle bike = new MotorBike ();
    rickshaw.move ();		//prints "Vehicle can move!"
    bike.move ();		// prints "Motorbike can move and accelarate too!"
  }
}