{"id":26164,"date":"2024-04-01T11:23:43","date_gmt":"2024-04-01T05:53:43","guid":{"rendered":"https:\/\/www.mygreatlearning.com\/blog\/polymorphism-in-java\/"},"modified":"2025-01-06T19:11:58","modified_gmt":"2025-01-06T13:41:58","slug":"polymorphism-in-java","status":"publish","type":"post","link":"https:\/\/www.mygreatlearning.com\/blog\/polymorphism-in-java\/","title":{"rendered":"Polymorphism in Java with Examples"},"content":{"rendered":"\n

What is Polymorphism in Java?<\/strong><\/h2>\n\n\n\n

Polymorphism in Java<\/strong> is the task that performs a single action in different ways.<\/p>\n\n\n\n

So, languages that do not support polymorphism are not 'Object-Oriented Languages', but 'Object-Based Languages'. Ada, for instance, is one such language. Since Java supports polymorphism, it is an Object-Oriented Language<\/a>.<\/p>\n\n\n\n

Polymorphism occurs when there is inheritance, i.e., many classes are related.<\/p>\n\n\n\n

Inheritance is a powerful feature in Java. Java Inheritance<\/a> lets one class acquire the properties and attributes of another class. Polymorphism in Java allows us to use these inherited properties to perform different tasks. Thus, allowing us to achieve the same action in many different ways.<\/p>\n\n\n\n

What is Polymorphism?<\/strong><\/h2>\n\n\n\n

The derivation of the word Polymorphism is from two different Greek words- poly and morphs. \u201cPoly\u201d means numerous, and \u201cMorphs\u201d means forms. So, polymorphism means innumerable forms. Polymorphism, therefore, is one of the most significant features of Object-Oriented Programming.<\/p>\n\n\n\n

\n\t
\n\t\t

Must Learn Core Java Topics <\/h2>\t\n\t\t
\n\t\t\t\t\t\t Java Algorithms Free Course <\/a>\n\t\t\t\t\t\t Java Data Structures Free Course <\/a>\n\t\t\t\t\t\t JDBC In Java Free Course <\/a>\n\t\t\t\t\t\t Java Basic Programs Free Course <\/a>\n\t\t\t\t\t\t Java Free Courses <\/a>\n\t\t\t\t\t<\/div>\n\t<\/div>\n<\/div>\n\n\n\n\n

Real-Life Examples of Polymorphism<\/strong><\/h2>\n\n\n\n

An individual can have different relationships with different people. A woman can be a mother, a daughter, a sister, and a friend, all at the same time, i.e. she performs other behaviors in different situations.<\/p>\n\n\n\n

The human body has different organs. Every organ has a different function to perform; the heart is responsible for blood flow, the lungs for breathing, the brain for cognitive activity, and the kidneys for excretion. So we have a standard method function that performs differently depending upon the organ of the body. <\/p>\n\n\n\n

Polymorphism in Java Example <\/strong><\/h4>\n\n\n\n

A superclass named \u201cShapes\u201d has a method called \u201carea()\u201d. Subclasses of \u201cShapes\u201d can be \u201cTriangle\u201d, \u201ccircle\u201d, \u201cRectangle\u201d, etc. Each subclass has its way of calculating area. Using Inheritance and Polymorphism means, the subclasses can use the \u201carea()\u201d method to find the area\u2019s formula for that shape.<\/p>\n\n\n

\nclass Shapes {\n  public void area() {\n    System.out.println("The formula for area of ");\n  }\n}\nclass Triangle extends Shapes {\n  public void area() {\n    System.out.println("Triangle is \u00bd * base * height ");\n  }\n}\nclass Circle extends Shapes {\n  public void area() {\n    System.out.println("Circle is 3.14 * radius * radius ");\n  }\n}\nclass Main {\n  public static void main(String[] args) {\n    Shapes myShape = new Shapes();  \/\/ Create a Shapes object\n    Shapes myTriangle = new Triangle();  \/\/ Create a Triangle object\n    Shapes myCircle = new Circle();  \/\/ Create a Circle object\n    myShape.area();\n    myTriangle.area();\n    myShape.area();\n    myCircle.area();\n  }\n}\n<\/pre><\/div>\n\n\n
Output:<\/strong><\/p>\n\n\n\n
The formula for the area of the Triangle is \u00bd * base * height
The formula for the area of the Circle is 3.14 * radius * radius<\/p>\n\n\n\n
class Shape {\n    public void draw() {\n        System.out.println(\"Drawing a shape\");\n    }\n}\n\nclass Circle extends Shape {\n    @Override\n    public void draw() {\n        System.out.println(\"Drawing a circle\");\n    }\n}\n\nclass Square extends Shape {\n    @Override\n    public void draw() {\n        System.out.println(\"Drawing a square\");\n    }\n}\n\nclass Main {\n    public static void main(String[] args) {\n        Shape s1 = new Circle();\n        Shape s2 = new Square();\n\n        s1.draw(); \/\/ Output: \"Drawing a circle\"\n        s2.draw(); \/\/ Output: \"Drawing a square\"\n    }\n}\n<\/code><\/pre>\n\n\n\n
In this example, we have a base class Shape<\/code> with a single method draw()<\/code> that prints \"Drawing a shape\" to the console. We then create two subclasses, Circle<\/code> and Square<\/code>, that override the draw()<\/code> method to print \"Drawing a circle\" and \"Drawing a square\" respectively.<\/p>\n\n\n\n
In the main<\/code> method, we create two instances of the Shape<\/code> class, s1<\/code> and s2<\/code>, which are actually instances of the Circle<\/code> and Square<\/code> subclasses. When we call the draw()<\/code> method on these objects, the correct implementation is called based on the actual type of the object, this is run-time polymorphism. The program will output: \"Drawing a circle\" and \"Drawing a square\"<\/p>\n\n\n\n
In this example, the draw()<\/code> method is overridden in the subclasses, and this allows for the program to determine which method to use at runtime. This is known as runtime polymorphism or dynamic polymorphism, Because at runtime the JVM determines the actual type of the object and calls the corresponding method.<\/p>\n\n\n\n
Also Read: OOPs concepts in Java<\/a><\/strong><\/p>\n\n\n\n
Types of Polymorphism<\/strong><\/h2>\n\n\n\n
You can perform Polymorphism in Java via two different methods:<\/p>\n\n\n\n
    \n
  1. Method Overloading<\/li>\n\n\n\n
  2. Method Overriding<\/li>\n<\/ol>\n\n\n\n
    <\/p>\n\n\n\n
    What is Method Overloading in Java?<\/strong><\/h3>\n\n\n\n
    Method overloading<\/strong> is the process that can create multiple methods of the same name in the same class, and all the methods work in different ways. Method overloading occurs when there is more than one method of the same name in the class.  <\/p>\n\n\n\n
    Example of Method Overloading in Java<\/strong><\/h4>\n\n\n\n
    class Shapes {\n  public void area() {\n    System.out.println(\"Find area \");\n  }\npublic void area(int r) {\n    System.out.println(\"Circle area = \"+3.14*r*r);\n  }\n\npublic void area(double b, double h) {\n    System.out.println(\"Triangle area=\"+0.5*b*h);\n  }\npublic void area(int l, int b) {\n    System.out.println(\"Rectangle area=\"+l*b);\n  }\n\n\n}\n\nclass Main {\n  public static void main(String[] args) {\n    Shapes myShape = new Shapes();  \/\/ Create a Shapes object\n    \n    myShape.area();\n    myShape.area(5);\n    myShape.area(6.0,1.2);\n    myShape.area(6,2);\n    \n  }\n}<\/code><\/pre>\n\n\n\n
    Output:<\/strong><\/p>\n\n\n\n
    Find area
    Circle area = 78.5
    Triangle area=3.60
    Rectangle area=12<\/p>\n\n\n\n
    What is Method Overriding in Java?<\/strong><\/h3>\n\n\n\n
    Method overriding is the process when the subclass or a child class has the same method as declared in the parent class.<\/p>\n\n\n\n
    Example of Method Overriding in Java <\/strong><\/h3>\n\n\n\n
    class Vehicle{  \n  \/\/defining a method  \n  void run(){System.out.println(\"Vehicle is moving\");}  \n}  \n\/\/Creating a child class  \nclass Car2 extends Vehicle{  \n  \/\/defining the same method as in the parent class  \n  void run(){System.out.println(\"car is running safely\");}  \n  \n  public static void main(String args[]){  \n  Car2 obj = new Car2();\/\/creating object  \n  obj.run();\/\/calling method  \n  }  \n}  <\/code><\/pre>\n\n\n\n
    Output:<\/strong><\/p>\n\n\n\n
    Car is running safely<\/pre>\n\n\n\n
    Also, Polymorphism in Java can be classified into two types, i.e:<\/p>\n\n\n\n
      \n
    1. Static\/Compile-Time Polymorphism<\/li>\n\n\n\n
    2. Dynamic\/Runtime Polymorphism<\/li>\n<\/ol>\n\n\n\n
      What is Compile-Time Polymorphism in Java?<\/strong><\/h3>\n\n\n\n
      Compile Time Polymorphism In<\/strong> Java is also known as Static Polymorphism.<\/strong> Furthermore, the call to the method is resolved at compile-time. Compile-Time polymorphism is achieved through Method Overloading<\/strong>. This type of polymorphism can also be achieved through Operator Overloading<\/strong>. However, Java does not support Operator Overloading.<\/p>\n\n\n\n
      Method Overloading is when a class has multiple methods with the same name, but the number, types, and order of parameters and the return type of the methods are different. Java allows the user freedom to use the same name for various functions as long as it can distinguish between them by the type and number of parameters. Check out some of the important questions on run time polymorphism in java interview questions<\/a>.<\/p>\n\n\n\n
      Example of Compile-Time Polymorphism in Java <\/strong><\/h3>\n\n\n\n
      We will do addition in Java and understand the concept of compile time polymorphism using subtract() <\/em><\/p>\n\n\n\n
      package staticPolymorphism; \npublic class Addition \n{ \nvoid sum(int a, int b) \n{ \nint c = a+b; \nSystem.out.println(\u201c Addition of two numbers :\u201d +c); } \nvoid sum(int a, int b, int e) \n{ \nint c = a+b+e; \nSystem.out.println(\u201c Addition of three numbers :\u201d +c); } \npublic static void main(String[] args) \n{ \nAddition obj = new Addition(); \nobj.sum ( 30,90); \nobj.sum(45, 80, 22); \n} \n}\n<\/code><\/pre>\n\n\n\n
      The output of the program will be: <\/strong><\/em><\/p>\n\n\n\n
      Sum of two numbers: 120 <\/em><\/p>\n\n\n\n
      Sum of three numbers: 147 <\/em><\/p>\n\n\n\n
      In this program, the sum() method overloads with two types via different parameters. <\/em><\/p>\n\n\n\n
      This is the basic concept of compile-time polymorphism in java where we can perform various operations by using multiple methods having the same name.<\/em><\/p>\n\n\n\n
      What is Runtime Polymorphism in Java?<\/strong><\/h3>\n\n\n\n
      Runtime polymorphism<\/strong> in Java is also popularly known as Dynamic Binding or Dynamic Method Dispatch.<\/strong> In this process, the call to an overridden method is resolved dynamically at runtime rather than at compile-time. You can achieve Runtime polymorphism via Method Overriding<\/strong>.<\/p>\n\n\n\n
      Method Overriding is done when a child or a subclass has a method with the same name, parameters, and return type as the parent or the superclass; then that function overrides the function in the superclass. In simpler terms, if the subclass provides its definition to a method already present in the superclass; then that function in the base class is said to be overridden.<\/p>\n\n\n\n
      Also, it should be noted that runtime polymorphism can only be achieved through functions and not data members. <\/p>\n\n\n\n
      Overriding is done by using a reference variable of the superclass. The method to be called is determined based on the object which is being referred to by the reference variable. This is also known as Upcasting<\/strong>.<\/p>\n\n\n\n
      Upcasting takes place when the Parent class\u2019s reference variable refers to the object of the child class. For example:<\/p>\n\n\n\n
      class A{} \nclass B extends A{}  \nA a=new B(); \/\/upcasting<\/code><\/pre>\n\n\n\n
      Examples of Runtime Polymorphism in Java<\/strong><\/h4>\n\n\n\n
      Example 1:<\/strong><\/p>\n\n\n\n
      In this example, we are creating one superclass Animal and three subclasses, Herbivores, Carnivores, and Omnivores. Subclasses extend the superclass and override its eat() method. We will call the eat() method by the reference variable of Parent class, i.e. Animal class. As it refers to the base class object and the base class method overrides the superclass method; the base class method is invoked at runtime. As Java Virtual Machine or the JVM and not the compiler determines method invocation, it is, therefore, runtime polymorphism.<\/p>\n\n\n\n
      class Animal{  \n  void eat(){\nSystem.out.println(\"Animals Eat\");\n}  \n}  \nclass herbivores extends Animal{  \n  void eat(){\nSystem.out.println(\"Herbivores Eat Plants\");\n} \n  }\nclass omnivores extends Animal{  \n  void eat(){\nSystem.out.println(\"Omnivores Eat Plants and meat\");\n} \n  }\nclass carnivores extends Animal{  \n  void eat(){\nSystem.out.println(\"Carnivores Eat meat\");\n} \n  }\nclass main{\n  public static void main(String args[]){ \n    Animal A = new Animal();\n    Animal h = new herbivores(); \/\/upcasting  \n\tAnimal o = new omnivores(); \/\/upcasting  \n    Animal c = new carnivores(); \/\/upcasting  \n    A.eat();\n    h.eat();\n    o.eat();  \n    c.eat();  \n  \n  }  \n}  <\/code><\/pre>\n\n\n\n
      Output:<\/strong><\/p>\n\n\n\n
      Animals eat
      Herbivores Eat Plants
      Omnivores Eat Plants and meat
      Carnivores eat meat<\/p>\n\n\n\n
      Example 2:<\/strong><\/p>\n\n\n\n
      In this example, we are creating one superclass Hillstations and three subclasses Manali, Mussoorie, Gulmarg. Subclasses extend the superclass and override its location() and famousfor() method. We will call the location() and famousfor() method by the Parent class\u2019, i.e. Hillstations class. As it refers to the base class object and the base class method overrides the superclass method; the base class method is invoked at runtime. Also, as Java Virtual Machine or the JVM and not the compiler determines method invocation, it is runtime polymorphism.<\/p>\n\n\n\n
      class Hillstations{  \n  void location(){\nSystem.out.println(\"Location is:\");\n}  \nvoid famousfor(){\nSystem.out.println(\"Famous for:\");\n}  \n\n}  \nclass Manali extends Hillstations {  \n  void location(){\nSystem.out.println(\"Manali is in Himachal Pradesh\");\n}  \nvoid famousfor(){\nSystem.out.println(\"It is Famous for Hadimba Temple and adventure sports\");\n}  \n  }\nclass Mussoorie extends Hillstations {  \n  void location(){\nSystem.out.println(\"Mussoorie is in Uttarakhand\");\n}  \nvoid famousfor(){\nSystem.out.println(\"It is Famous for education institutions\");\n}  \n  }\nclass Gulmarg extends Hillstations {  \n  void location(){\nSystem.out.println(\"Gulmarg is in J&K\");\n}  \nvoid famousfor(){\nSystem.out.println(\"It is Famous for skiing\");\n}  \n  }\nclass main{\n  public static void main(String args[]){ \n    Hillstations A = new Hillstations();\n    Hillstations M = new Manali();\n\n    Hillstations Mu = new Mussoorie();\n\n    Hillstations G = new Gulmarg();\n\n    A.location();\nA.famousfor();\n\nM.location();\nM.famousfor();\n\nMu.location();\nMu.famousfor();\n\nG.location();\nG.famousfor();\n  }  \n}  <\/code><\/pre>\n\n\n\n
      Output:<\/strong><\/p>\n\n\n\n
      Location is:
      Famous for:
      Manali is in Himachal Pradesh
      It is Famous for Hadimba Temple and adventure sports
      Mussoorie is in Uttarakhand
      It is Famous for education institutions
      Gulmarg is in J&K
      It is Famous for skiing<\/p>\n\n\n\n
      Example of run-time polymorphism in java <\/strong><\/h3>\n\n\n\n
      We will create two classes Car and Innova, Innova class will extend the car class and will override its run() method.<\/p>\n\n\n\n
      class Car \n{ \nvoid run() \n{ \nSystem.out.println(\u201c running\u201d); \n} \n}\nclass innova extends Car \n{ \nvoid run(); \n{ \nSystem.out.println(\u201c running fast at 120km\u201d); \n} \npublic static void main(String args[]) \n{ \nCar c = new innova(); \nc.run(); \n} \n} \n<\/code><\/pre>\n\n\n\n
      The output of the following program will be; <\/em><\/p>\n\n\n\n
      Running fast at 120 km. <\/em><\/p>\n\n\n\n
      Another example for run-time polymorphism in Java <\/p>\n\n\n\n
      Now, let us check if we can achieve runtime polymorphism via data members. <\/em><\/p>\n\n\n\n
      class car \n{ \nint speedlimit = 125; \n} \nclass innova extends car \n{ \nint speedlimit = 135; \npublic static void main(String args[]) \n{ \ncar obj = new innova(); \nSystem.out.println(obj.speedlimit);\n}\n<\/code><\/pre>\n\n\n\n
      The output of the following program will be : <\/strong><\/em><\/p>\n\n\n\n
      125 <\/em><\/p>\n\n\n\n
      This clearly implies we can't achieve Runtime polymorphism via data members. In short, a method is overridden, not the data members.<\/em><\/p>\n\n\n\n
      Runtime polymorphism with multilevel inheritance<\/strong><\/h3>\n\n\n\n
      class grandfather \n{ \nvoid swim() \n{ \nSystem.out.println(\u201c Swimming\u201d); \n} \n} \nclass father extends grandfather \n{ \nvoid swim() \n{ \nSystem.out.println(\u201c Swimming in river\u201d); \n} \n} \nclass son extends father \n{ \nvoid swim() \n{ \nSystem.out.println(\u201c Swimming in pool\u201d);\n} \npublic static void main(String args[]) \n{ \ngrandfather f1,f2,f3; \nf1 =new grandfather(); \nf2 = new father(); \nf3 = new son(); \nf1.swim(); \nf2.swim(); \nf3.swim(): \n} \n} \n<\/code><\/pre>\n\n\n\n
      The output of the following program will be: <\/strong><\/em><\/p>\n\n\n\n
      Swimming<\/em>, Swimming in river<\/em>, Swimming in pool<\/em><\/p>\n\n\n\n
      Another runtime polymorphism with multilevel inheritance example<\/strong><\/p>\n\n\n\n
      class soundAnimal \n{ \npublic void Sound() \n{ \nSystem.out.println(\"Different sounds of animal\"); }\n} \nclass buffalo extends soundAnimal \n{ \npublic void Sound() \n{ \nSystem.out.println(\"The buffalo sound- gho,gho\"); } \n} \nclass snake extends soundAnimal \n{ \npublic void Sound() \n{ \nSystem.out.println(\"The snake sound- his,his\"); } \n} \nclass tiger extends soundAnimal\n{ \npublic void Sound() \n{ \nSystem.out.println(\"The tiger sounds- roooo, rooo\"); } \n} \npublic class Animal Main \n{ \npublic static void main(String[] args) \n{ \nsoundAnimal Animal = new soundAnimal(); soundAnimal buffalo = new buffalo(); \nsoundAnimal snake = new snake(); \nsoundAnimal tiger = new tiger(); \nAnimal.Sound(); \nbuffalo.Sound();\nsnake.Sound(); \ntiger.Sound(); \n} \n} \n<\/code><\/pre>\n\n\n\n
      The output of the following program will be; <\/strong><\/em><\/p>\n\n\n\n
      The buffalo sound- gho,gho <\/em><\/p>\n\n\n\n
      The snake sound- his,his <\/em><\/p>\n\n\n\n
      The tiger sound- roooo,roooo <\/em><\/p>\n\n\n\n
      We hope you got an idea about runtime and compile-time polymorphism.<\/p>\n\n\n\n
      Polymorphic Subtypes<\/strong><\/h2>\n\n\n\n
      Subtype basically means that a subtype can serve as another type's subtype, sounds a bit complicated? <\/p>\n\n\n\n
      Let's understand this with the help of an example:<\/p>\n\n\n\n
      Assuming we have to draw some arbitrary shapes, we can introduce a class named \u2018shape\u2019 with a draw() method. By overriding draw() with other subclasses such as circle, square, rectangle, trapezium, etc we will introduce an array of type \u2018shape\u2019 whose elements store references will refer to \u2018shape\u2019 subclass references. Next time, we will call draw(), all shapes instances draw () method will be called.<\/p>\n\n\n\n
      This Subtype polymorphism generally relies on upcasting and late binding. A casting where you cast up the inheritance hierarchy from subtype to a supertype is termed upcasting.<\/p>\n\n\n\n
      To call non-final instance methods we use late binding. In short, a compiler should not perform any argument checks, type checks, method calls, etc, and leave everything on the runtime. <\/p>\n\n\n\n
      What is Polymorphism in Programming?<\/strong><\/h2>\n\n\n\n
      Polymorphism in programming is defined usage of a single symbol to represent multiple different types.<\/p>\n\n\n\n
      What is Polymorphism Variables?<\/strong><\/h2>\n\n\n\n
      A polymorphic variable<\/strong> is defined as a variable that can hold values of different types during the course of execution.<\/p>\n\n\n\n
      Why use Polymorphism in Java?<\/strong><\/h2>\n\n\n\n
      Polymorphism in Java makes it possible to write a method that can correctly process lots of different types of functionalities that have the same name. We can also gain consistency in our code by using polymorphism.<\/p>\n\n\n\n
      Advantages of Polymorphism in Java <\/strong><\/h3>\n\n\n\n
        \n
      1. It provides reusability to the code. The classes that are written, tested and implemented can be reused multiple times. Furthermore, it saves a lot of time for the coder. Also, the one can change the code without affecting the original code.<\/li>\n\n\n\n
      2. A single variable can be used to store multiple data values. The value of a variable you inherit from the superclass into the subclass can be changed without changing that variable\u2019s value in the superclass; or any other subclasses.<\/li>\n\n\n\n
      3. With lesser lines of code, it becomes easier for the programmer to debug the code.<\/li>\n<\/ol>\n\n\n\n
        Characteristics of Polymorphism<\/strong><\/h3>\n\n\n\n
        Polymorphism has many other characteristics other than Method Overloading and Method Overriding. They include:<\/p>\n\n\n\n