The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language. Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class.

Polymorphism can exists in two ways... 1. Static polymorphism - Overloading
2. Dynamic polymorphism  - Overriding

Overloading : Creating mutiple methods with same name in a class but with different signatures (either number of parameters should be different or type of parameters should be different in each method)
Overriding :  Creating same method same parameters but with different behavior in both super class and extended class is called as overriding.

Dynamic binding is nothing but choosing which method to chose when super class object is created with extended class type.
Please have a look at the below program and output to understand the polymorphisms...

public class Ploymorphism {

    public interface Vegetarian{
        void eatVeg();
    }
    public class Animal{
        void eat(){
            System.out.println("All animals can eat");
        }
    }
    public class Deer extends Animal implements Vegetarian{

        public void eat(String veg) {
            System.out.println("I am eating :"+veg);
        }
        public void eatVeg(){
            System.out.println("I eat only veg");
        }

    }
    public class Tiger extends Animal{
        void eat(){
            System.out.println("I'm tiger, I eat what I want");
        }
        void eat(String veg, String nonveg){
            System.out.println("I can eat:"+veg+" and "+nonveg);
        }
    }
    public static void main(String[] args) {
        System.out.println("Java has two types of polymorphism");
        System.out.println("1.Static Polymorphism : Achived using \"overloading\" ");
        Ploymorphism p = new Ploymorphism();
        Tiger tiger = p.new Tiger();
        tiger.eat("leaves", "creatures");
        System.out.println("Tiger has two methods with same name but with different paramaetrs/ signatiures(either no of parameters should be different or type of paramters should be different)");
        System.out.println("2.Dynamic Polymorphism : Achived using \"overriding\" ");
        Deer deer = p.new Deer();
        deer.eat("carrot");
        System.out.println("deer is extended from animal but eat method has different in the deer than animal class- it is overriding");
        Animal whiteTiger = p.new Tiger();
        whiteTiger.eat();
        //whiteTiger.eat("prawns","fish");
        //System.out.println("The above commented line gives error as there is no eat method of such type in the animal class");

    }

}

Ouput of the above program :

Java has two types of polymorphism
1.Static Polymorphism : Achived using "overloading"
I can eat:leaves and creatures
Tiger has two methods with same name but with different paramaetrs/ signatiures(either no of parameters should be different or type of paramters should be different)
2.Dynamic Polymorphism : Achived using "overriding"
I am eating :carrot
deer is extended from animal but eat method has different in the deer than animal class- it is overriding
I'm tiger, I eat what I want

Reference : [1] [2] [3]

Do you like this article? Share It!