{"id":1245,"date":"2016-03-25T07:30:47","date_gmt":"2016-03-25T07:30:47","guid":{"rendered":"http:\/\/abhiandroid.com\/java\/?page_id=1245"},"modified":"2016-03-25T07:30:47","modified_gmt":"2016-03-25T07:30:47","slug":"polymorphism","status":"publish","type":"page","link":"https:\/\/abhiandroid.com\/java\/polymorphism","title":{"rendered":"Polymorphism In Java With Example"},"content":{"rendered":"

Polymorphism means one name and many duties. Polymorphism refers to the ability of one thing to take many(Poly) distinct forms(Morphism). It is the property by which same message is send to objects of different classes and the objects behave differently. It is a very powerful concept that allows the designing of amazingly flexible applications.<\/p>\n

Polymorphism can be defined as the ability to use the same for two or more related but technically different tasks. In other words, polymorphism can be defined as interface that can be used to perform related but different tasks.<\/p>\n

\n

Types of Polymorphism<\/strong><\/h4>\n

There are two types of polymorphism:<\/p>\n

    \n
  1. Compile time polymorphism<\/li>\n
  2. Run time polymorphism<\/li>\n<\/ol>\n

    Compile Time Polymorphism<\/u><\/strong>: <\/strong><\/span><\/p>\n

    Whenever an object is bound with their functionality at compile time this is known as compile time polymorphism. At compile time, java knows which method to call by checking the method signatures. So this is called compile time polymorphism or static or early binding.<\/p>\n

    Implementation of Compile time polymorphism:<\/strong><\/p>\n

    Compile time polymorphism is achieved through method\u00a0overloading.\u00a0Method Overloading<\/a><\/strong> says you can have more than one function with a same name in one class having a different prototype. Function overloading is one of the way to achieve polymorphism but it depends on technology that which type of polymorphism we adopt. In java we achieve function overloading at run time.<\/p>\n

    Program Example of Compile time polymorphism:<\/strong><\/p>\n

    Let us take an example to show the working of compile time polymorphism through function overloading.<\/p>\n

    Step 1: <\/strong>First we create a class Addition <\/strong>in which we declare three add() methods with different parameters:<\/p>\n

    class Addition\r\n{\r\n\r\n   public int add(int m,int n)\r\n   {\r\n\r\n      return m+n;\r\n   }\r\n\r\n   public int add(int m,int n,int o)\r\n   {\r\n\r\n     return m+n+o;\r\n   }\r\n\r\n   public int add(int m,double n)\r\n   {\r\n\r\n     return m+(int)n;\r\n   }\r\n\r\n}<\/pre>\n
    Step 2: <\/strong>Second we create a class PrintAdd <\/strong>in which we call the above class methods by creating an object:<\/p>\n
    class PrintAdd\r\n{\r\n\r\n  public static void main(String args[])\r\n  {\r\n\r\n     Addition a=new Addition();\r\n\r\n    System.out.println(a.add(2,3));\r\n\r\n    System.out.println(a.add(2,3,4));\r\n\r\n    System.out.println(a.add(2,3.4));\r\n  }\r\n\r\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    5\r\n9\r\n5\r\n<\/pre>\n
    Explanation of Example:<\/strong><\/p>\n
    In above example there are three versions of add methods. The first method takes two parameters or arguments while the second one takes three parameters. In the third method there is change in type of parameters. The compiler looks at the method signature and decides which method to call for a particular method call at compile time.<\/p>\n
    Run Time Polymorphism<\/u><\/strong><\/span>:<\/span> <\/strong><\/p>\n
    Whenever an object is bound with the functionality at run time, this is known as runtime polymorphism. You can have a method in subclass that overrides the method in its parent classes with the same name and parameters. Java virtual machine determines the proper method to call at the runtime, not at the compile time. It is also called dynamic or late binding.<\/p>\n
    Implementation of Run time polymorphism:<\/strong><\/p>\n
    Run time or dynamic polymorphism is achieved(implemented) through method overriding. Method overriding<\/a><\/strong> says child class has the same method as declared in the parent class. It means if child class provides the specific implementation of the method that has been provided by one of its parent class then it is known as method overriding.<\/p>\n
    Program Example of Run time polymorphism:<\/strong><\/p>\n
    Let us take an example to show the working of run time polymorphism through method overriding.<\/p>\n
    Step 1: <\/strong>First we create a class Vehicle <\/strong>in which we declare a move() method:<\/p>\n
    class Vehicle\r\n{\r\n\r\n  public void move()\r\n  {\r\n\r\n    System.out.println(\"vehicles can move\");\r\n  }\r\n\r\n}\r\n<\/pre>\n
    Step 2: <\/strong>Second we create a class Bike <\/strong>which extends the class Vehicle:<\/strong><\/p>\n
    class Bike extends Vehicle\r\n{\r\n\r\n  public void move()\r\n  {\r\n\r\n    System.out.println(\"bike can move and accelerate too\");\r\n  }\r\n\r\n}<\/pre>\n
    Step 3: <\/strong>Third we create a class TestVehicle <\/strong>in which we create an object and call the above class method:<\/p>\n
    class TestVehicle\r\n{\r\n\r\n  public static void main(String args[])\r\n  {\r\n\r\n    Vehicle v=new Bike();\r\n\r\n    v.move();\r\n\r\n    Vehicle v1=new Vehicle();\r\n\r\n    v1.move();\r\n\r\n  }\r\n\r\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    Bike can move and accelerate too\r\nVehicles can move<\/pre>\n
    Explanation:<\/strong><\/p>\n
    In above example, it should be noted that in the first call to move()<\/strong>,the reference type is Vehicle<\/strong> and the object is being referenced is Bike<\/strong>. So when a call to move()<\/strong> is made, java waits until runtime to check which object is being pointed to by reference. In this case,the object is of class Bike<\/strong>. So the move()<\/strong> method of Bike<\/strong> class will be called. In the second call to move()<\/strong>,the object is of class Vehicle<\/strong>. So the move()<\/strong> method of Vehicle<\/strong> will be called.<\/p>\n
    \n
    Difference Between Compile Time and Run Time Polymorphism<\/strong><\/h4>\n
    Compile time polymorphism:<\/u><\/strong><\/span><\/p>\n
      \n
    1. In compile time polymorphism, call is resolved by the compiler.<\/li>\n
    2. It is also known as static or early binding.<\/li>\n
    3. It is achieved by function overloading and operator overloading.<\/li>\n
    4. It provides fast execution because known early at compile time.<\/li>\n
    5. Compile time polymorphism is less flexible as all things execute at compile time.<\/li>\n<\/ol>\n
      \u00a0Run time polymorphism :<\/u><\/strong><\/span><\/p>\n
        \n
      1. In run time polymorphism, call is not resolved by the compiler.<\/li>\n
      2. It is also known as dynamic binding or late binding.<\/li>\n
      3. It is achieved by virtual functions.<\/li>\n
      4. It provides slow execution as compare to early binding because it is known as runtime.<\/li>\n
      5. Run time polymorphism is more flexible as all things execute at run time.<\/li>\n<\/ol>\n
        \n
        Importance of Polymorphism<\/strong><\/h4>\n