{"id":1212,"date":"2022-02-25T16:53:53","date_gmt":"2022-02-25T16:53:53","guid":{"rendered":"https:\/\/mdr.foobrdigital.com\/?p=1212"},"modified":"2022-02-25T16:53:53","modified_gmt":"2022-02-25T16:53:53","slug":"java-polymorphism-2","status":"publish","type":"post","link":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/2022\/02\/25\/java-polymorphism-2\/","title":{"rendered":"Java Polymorphism"},"content":{"rendered":"\n

In this tutorial, we will learn about Java polymorphism and its implementation with the help of examples.<\/p>\n\n\n\n

Polymorphism is an important concept of object-oriented programming. It simply means more than one form.<\/p>\n\n\n\n

That is, the same entity (method or operator or object) can perform different operations in different scenarios.<\/p>\n\n\n\n

\n\n\n\n

Example: Java Polymorphism<\/h2>\n\n\n\n
class Polygon {\n\n  \/\/ method to render a shape\n  public void render() {\n    System.out.println(\"Rendering Polygon...\");\n  }\n}\n\nclass Square extends Polygon {\n\n  \/\/ renders Square\n  public void render() {\n    System.out.println(\"Rendering Square...\");\n  }\n}\n\nclass Circle extends Polygon {\n\n  \/\/ renders circle\n  public void render() {\n    System.out.println(\"Rendering Circle...\");\n  }\n}\n\nclass Main {\n  public static void main(String[] args) {\n    \n    \/\/ create an object of Square\n    Square s1 = new Square();\n    s1.render();\n\n    \/\/ create an object of Circle\n    Circle c1 = new Circle();\n    c1.render();\n  }\n}<\/code><\/pre>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
Rendering Square...\nRendering Circle...<\/samp><\/code><\/pre>\n\n\n\n
In the above example, we have created a superclass: Polygon<\/var> and two subclasses: Square<\/var> and Circle<\/var>. Notice the use of the render()<\/code> method.<\/p>\n\n\n\n
The main purpose of the render()<\/code> method is to render the shape. However, the process of rendering a square is different than the process of rendering a circle.<\/p>\n\n\n\n
Hence, the render()<\/code> method behaves differently in different classes. Or, we can say render()<\/code> is polymorphic.<\/p>\n\n\n\n
\n\n\n\n
Why Polymorphism?<\/h3>\n\n\n\n
Polymorphism allows us to create consistent code. In the previous example, we can also create different methods: renderSquare()<\/code> and renderCircle()<\/code> to render Square<\/var> and Circle<\/var>, respectively.<\/p>\n\n\n\n
This will work perfectly. However, for every shape, we need to create different methods. It will make our code inconsistent.<\/p>\n\n\n\n
To solve this, polymorphism in Java allows us to create a single method render()<\/code> that will behave differently for different shapes.<\/p>\n\n\n\n
Note<\/strong>: The print()<\/code> method is also an example of polymorphism. It is used to print values of different types like char<\/code>, int<\/code>, string<\/code>, etc.<\/p>\n\n\n\n
\n\n\n\n
We can achieve polymorphism in Java using the following ways:<\/p>\n\n\n\n
  1. Method Overriding<\/li>
  2. Method Overloading<\/li>
  3. Operator Overloading<\/li><\/ol>\n\n\n\n
    \n\n\n\n
    Java Method Overriding<\/h2>\n\n\n\n
    During\u00a0inheritance in Java, if the same method is present in both the superclass and the subclass. Then, the method in the subclass overrides the same method in the superclass. This is called method overriding.<\/p>\n\n\n\n
    In this case, the same method will perform one operation in the superclass and another operation in the subclass. For example,<\/p>\n\n\n\n
    Example 1: Polymorphism using method overriding<\/h3>\n\n\n\n
    class Language {\n  public void displayInfo() {\n    System.out.println(\"Common English Language\");\n  }\n}\n\nclass Java extends Language {\n  @Override\n  public void displayInfo() {\n    System.out.println(\"Java Programming Language\");\n  }\n}\n\nclass Main {\n  public static void main(String[] args) {\n\n    \/\/ create an object of Java class\n    Java j1 = new Java();\n    j1.displayInfo();\n\n    \/\/ create an object of Language class\n    Language l1 = new Language();\n    l1.displayInfo();\n  }\n}<\/code><\/pre>\n\n\n\n
    Output<\/strong>:<\/p>\n\n\n\n
    Java Programming Language\nCommon English Language<\/samp><\/code><\/pre>\n\n\n\n
    In the above example, we have created a superclass named Language<\/var> and a subclass named Java<\/var>. Here, the method displayInfo()<\/code> is present in both Language<\/var> and Java<\/var>.<\/p>\n\n\n\n
    The use of displayInfo()<\/code> is to print the information. However, it is printing different information in Language<\/var> and Java<\/var>.<\/p>\n\n\n\n
    Based on the object used to call the method, the corresponding information is printed.<\/p>\n\n\n\n
    \"displayInfo()
    Working of Java Polymorphism<\/figcaption><\/figure>\n\n\n\n
    Note<\/strong>: The method that is called is determined during the execution of the program. Hence, method overriding is a run-time polymorphism<\/strong>.<\/p>\n\n\n\n
    \n\n\n\n
    2. Java Method Overloading<\/h2>\n\n\n\n
    In a Java class, we can create methods with the same name if they differ in parameters. For example,<\/p>\n\n\n\n
    void func() { ... }\nvoid func(int a) { ... }\nfloat func(double a) { ... }\nfloat func(int a, float b) { ... }<\/code><\/pre>\n\n\n\n
    This is known as method overloading in Java. Here, the same method will perform different operations based on the parameter.<\/p>\n\n\n\n
    Example 3: Polymorphism using method overloading<\/h3>\n\n\n\n
    class Pattern {\n\n  \/\/ method without parameter\n  public void display() {\n    for (int i = 0; i < 10; i++) {\n      System.out.print(\"*\");\n    }\n  }\n\n  \/\/ method with single parameter\n  public void display(char symbol) {\n    for (int i = 0; i < 10; i++) {\n      System.out.print(symbol);\n    }\n  }\n}\n\nclass Main {\n  public static void main(String[] args) {\n    Pattern d1 = new Pattern();\n\n    \/\/ call method without any argument\n    d1.display();\n    System.out.println(\"\\n\");\n\n    \/\/ call method with a single argument\n    d1.display('#');\n  }\n}<\/code><\/pre>\n\n\n\n
    Output<\/strong>:<\/p>\n\n\n\n
    **********\n\n##########<\/samp><\/code><\/pre>\n\n\n\n
    In the above example, we have created a class named Pattern<\/var>. The class contains a method named display()<\/code> that is overloaded.<\/p>\n\n\n\n
    \/\/ method with no arguments\ndisplay() {...}\n\n\/\/ method with a single char type argument\ndisplay(char symbol) {...}<\/code><\/pre>\n\n\n\n
    Here, the main function of display()<\/code> is to print the pattern. However, based on the arguments passed, the method is performing different operations:<\/p>\n\n\n\n
    • prints a pattern of *<\/code>, if no argument is passed or<\/li>
    • prints pattern of the parameter, if a single char<\/code> type argument is passed.<\/li><\/ul>\n\n\n\n
      Note<\/strong>: The method that is called is determined by the compiler. Hence, it is also known as compile-time polymorphism.<\/p>\n\n\n\n
      \n\n\n\n
      3. Java Operator Overloading<\/h2>\n\n\n\n
      Some operators in Java behave differently with different operands. For example,<\/p>\n\n\n\n
      • +<\/code> operator is overloaded to perform numeric addition as well as string concatenation, and<\/li>
      • operators like &<\/code>, |<\/code>, and !<\/code> are overloaded for logical and bitwise operations.<\/li><\/ul>\n\n\n\n
        Let’s see how we can achieve polymorphism using operator overloading.<\/p>\n\n\n\n
        The +<\/code> operator is used to add two entities. However, in Java, the +<\/code> operator performs two operations.<\/p>\n\n\n\n
        1. When +<\/code> is used with numbers (integers and floating-point numbers), it performs mathematical addition. For example,<\/p>\n\n\n\n
        int a = 5;\nint b = 6;\n\n\/\/ + with numbers\nint sum = a + b;  \/\/ Output = 11<\/code><\/pre>\n\n\n\n
        2. When we use the +<\/code> operator with strings, it will perform string concatenation (join two strings). For example,<\/p>\n\n\n\n
        String first = \"Java \";\nString second = \"Programming\";\n\n\/\/ + with strings\nname = first + second;  \/\/ Output = Java Programming<\/code><\/pre>\n\n\n\n
        Here, we can see that the +<\/code> operator is overloaded in Java to perform two operations: addition<\/strong> and concatenation<\/strong>.<\/p>\n\n\n\n
        Note<\/strong>: In languages like C++, we can define operators to work differently for different operands. However, Java doesn’t support user-defined operator overloading.<\/p>\n\n\n\n
        \n\n\n\n
        Polymorphic Variables<\/h2>\n\n\n\n
        A variable is called polymorphic if it refers to different values under different conditions.<\/p>\n\n\n\n
        Object variables (instance variables) represent the behavior of polymorphic variables in Java. It is because object variables of a class can refer to objects of its class as well as objects of its subclasses.<\/p>\n\n\n\n
        Example: Polymorphic Variables<\/h3>\n\n\n\n
        class ProgrammingLanguage {\n  public void display() {\n    System.out.println(\"I am Programming Language.\");\n  }\n}\n\nclass Java extends ProgrammingLanguage {\n  @Override\n  public void display() {\n    System.out.println(\"I am Object-Oriented Programming Language.\");\n  }\n}\n\nclass Main {\n  public static void main(String[] args) {\n\n    \/\/ declare an object variable\n    ProgrammingLanguage pl;\n\n    \/\/ create object of ProgrammingLanguage\n    pl = new ProgrammingLanguage();\n    pl.display();\n\n    \/\/ create object of Java class\n    pl = new Java();\n    pl.display();\n  }\n}<\/code><\/pre>\n\n\n\n
        Output<\/strong>:<\/p>\n\n\n\n
        I am Programming Language.\nI am Object-Oriented Programming Language.<\/samp><\/code><\/pre>\n\n\n\n
        In the above example, we have created an object variable pl<\/var> of the ProgrammingLanguage<\/var> class. Here, pl<\/var> is a polymorphic variable. This is because,<\/p>\n\n\n\n
        • In statement pl = new ProgrammingLanguage()<\/code>, pl<\/var> refer to the object of the ProgrammingLanguage<\/var> class.<\/li>
        • And, in statement pl = new Java()<\/code>, pl<\/var> refer to the object of the Java<\/var> class.<\/li><\/ul>\n\n\n\n
          This is an example of upcasting in Java.<\/p>\n","protected":false},"excerpt":{"rendered":"
          In this tutorial, we will learn about Java polymorphism and its implementation with the help of examples. Polymorphism is an important concept of object-oriented programming. It simply means more than one form. That is, the same entity (method or operator or object) can perform different operations in different scenarios. Example: Java Polymorphism Output In the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[531],"tags":[],"_links":{"self":[{"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/posts\/1212"}],"collection":[{"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/comments?post=1212"}],"version-history":[{"count":0,"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/posts\/1212\/revisions"}],"wp:attachment":[{"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/media?parent=1212"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/categories?post=1212"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mudassirbackup.infinitycodestudio.com\/index.php\/wp-json\/wp\/v2\/tags?post=1212"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}