Scribd Logo
Upload

Welcome to Scribd!

  • 45 views

    Java Polymorphism

    Uploaded by

    Gabbriel Emmanuel Y. Cabagnot
    This document discusses Java polymorphism and provides examples to illustrate it. Polymorphism allows the same method to perform different operations depending on the object it is acting upon. It explains that polymorphism is achieved through method overriding, where a subclass defines a method with the same name as a parent class but different functionality. It also discusses method overloading and operator overloading as other ways to achieve polymorphism. Examples are provided to demonstrate polymorphism in action.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Java Polymorphism

    Uploaded by

    Gabbriel Emmanuel Y. Cabagnot
    45 views13 pages
    This document discusses Java polymorphism and provides examples to illustrate it. Polymorphism allows the same method to perform different operations depending on the object it is acting upon. It explains that polymorphism is achieved through method overriding, where a subclass defines a method with the same name as a parent class but different functionality. It also discusses method overloading and operator overloading as other ways to achieve polymorphism. Examples are provided to demonstrate polymorphism in action.

    Original Description:

    asgb bh

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document discusses Java polymorphism and provides examples to illustrate it. Polymorphism allows the same method to perform different operations depending on the object it is acting upon. It explains that polymorphism is achieved through method overriding, where a subclass defines a method with the same name as a parent class but different functionality. It also discusses method overloading and operator overloading as other ways to achieve polymorphism. Examples are provided to demonstrate polymorphism in action.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    45 views13 pages

    Java Polymorphism

    Uploaded by

    Gabbriel Emmanuel Y. Cabagnot
    This document discusses Java polymorphism and provides examples to illustrate it. Polymorphism allows the same method to perform different operations depending on the object it is acting upon. It explains that polymorphism is achieved through method overriding, where a subclass defines a method with the same name as a parent class but different functionality. It also discusses method overloading and operator overloading as other ways to achieve polymorphism. Examples are provided to demonstrate polymorphism in action.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 13

    Java Polymorphism

    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
    class Polygon {

    // method to render a shape


    public void render() {
    System.out.println("Rendering Polygon...");
    }
    }

    class Square extends Polygon {

    // renders Square
    public void render() {
    System.out.println("Rendering Square...");
    }
    }

    class Circle extends Polygon {

    // renders circle
    public void render() {
    System.out.println("Rendering Circle...");
    }
    }

    class Main {
    public static void main(String[] args) {

    // create an object of Square


    Square s1 = new Square();
    s1.render();

    // create an object of Circle


    Circle c1 = new Circle();
    c1.render();
    }
    }
    Run Code
    Output

    Rendering Square...
    Rendering Circle...

    In the above example, we have created a superclass:  Polygon  and two


    subclasses:  Square  and  Circle . Notice the use of the  render()  method.
    The main purpose of the  render()  method is to render the shape. However, the
    process of rendering a square is different than the process of rendering a
    circle.
    Hence, the  render()  method behaves differently in different classes. Or, we can
    say  render()  is polymorphic.

    Why Polymorphism?

    Polymorphism allows us to create consistent code. In the previous example,


    we can also create different methods:  renderSquare()  and  renderCircle()  to
    render  Square  and  Circle , respectively.
    This will work perfectly. However, for every shape, we need to create different
    methods. It will make our code inconsistent.

    To solve this, polymorphism in Java allows us to create a single


    method  render()  that will behave differently for different shapes.

    Note: The  print()  method is also an example of polymorphism. It is used to


    print values of different types like  char ,  int ,  string , etc.
    We can achieve polymorphism in Java using the following ways:

    1. Method Overriding
    2. Method Overloading
    3. Operator Overloading

    Java Method Overriding


    During inheritance 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.
    In this case, the same method will perform one operation in the superclass
    and another operation in the subclass. For example,

    Example 1: Polymorphism using method overriding


    class Language {
    public void displayInfo() {
    System.out.println("Common English Language");
    }
    }

    class Java extends Language {


    @Override
    public void displayInfo() {
    System.out.println("Java Programming Language");
    }
    }
    class Main {
    public static void main(String[] args) {

    // create an object of Java class


    Java j1 = new Java();
    j1.displayInfo();

    // create an object of Language class


    Language l1 = new Language();
    l1.displayInfo();
    }
    }
    Run Code

    Output:

    Java Programming Language


    Common English Language

    In the above example, we have created a superclass named  Language  and a


    subclass named  Java . Here, the method  displayInfo()  is present in
    both  Language  and  Java .
    The use of  displayInfo()  is to print the information. However, it is printing
    different information in  Language  and  Java .
    Based on the object used to call the method, the corresponding information is
    printed.
    Working of
    Java Polymorphism

    Note: The method that is called is determined during the execution of the
    program. Hence, method overriding is a run-time polymorphism.

    2. Java Method Overloading


    In a Java class, we can create methods with the same name if they differ in
    parameters. For example,

    void func() { ... }


    void func(int a) { ... }
    float func(double a) { ... }
    float func(int a, float b) { ... }

    This is known as method overloading in Java. Here, the same method will
    perform different operations based on the parameter.

    Example 3: Polymorphism using method overloading


    class Pattern {

    // method without parameter


    public void display() {
    for (int i = 0; i < 10; i++) {
    System.out.print("*");
    }
    }

    // method with single parameter


    public void display(char symbol) {
    for (int i = 0; i < 10; i++) {
    System.out.print(symbol);
    }
    }
    }

    class Main {
    public static void main(String[] args) {
    Pattern d1 = new Pattern();

    // call method without any argument


    d1.display();
    System.out.println("\n");

    // call method with a single argument


    d1.display('#');
    }
    }
    Run Code

    Output:

    **********

    ##########

    In the above example, we have created a class named  Pattern . The class
    contains a method named  display()  that is overloaded.

    // method with no arguments


    display() {...}

    // method with a single char type argument


    display(char symbol) {...}

    Here, the main function of  display()  is to print the pattern. However, based on
    the arguments passed, the method is performing different operations:
     prints a pattern of  * , if no argument is passed or
     prints pattern of the parameter, if a single  char  type argument is passed.

    Note: The method that is called is determined by the compiler. Hence, it is


    also known as compile-time polymorphism.

    3. Java Operator Overloading


    Some operators in Java behave differently with different operands. For
    example,

     +  operator is overloaded to perform numeric addition as well as string


    concatenation, and
     operators like  & ,  | , and  !  are overloaded for logical and bitwise
    operations.
    Let's see how we can achieve polymorphism using operator overloading.

    The  +  operator is used to add two entities. However, in Java, the  +  operator
    performs two operations.
    1. When  +  is used with numbers (integers and floating-point numbers), it
    performs mathematical addition. For example,
    int a = 5;
    int b = 6;

    // + with numbers
    int sum = a + b; // Output = 11

    2. When we use the  +  operator with strings, it will perform string concatenation
    (join two strings). For example,

    String first = "Java ";


    String second = "Programming";

    // + with strings
    name = first + second; // Output = Java Programming

    Here, we can see that the  +  operator is overloaded in Java to perform two
    operations: addition and concatenation.

    Note: In languages like C++, we can define operators to work differently for
    different operands. However, Java doesn't support user-defined operator
    overloading.

    Polymorphic Variables
    A variable is called polymorphic if it refers to different values under different
    conditions.

    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.
    Example: Polymorphic Variables
    class ProgrammingLanguage {
    public void display() {
    System.out.println("I am Programming Language.");
    }
    }

    class Java extends ProgrammingLanguage {


    @Override
    public void display() {
    System.out.println("I am Object-Oriented Programming Language.");
    }
    }

    class Main {
    public static void main(String[] args) {

    // declare an object variable


    ProgrammingLanguage pl;

    // create object of ProgrammingLanguage


    pl = new ProgrammingLanguage();
    pl.display();

    // create object of Java class


    pl = new Java();
    pl.display();
    }
    }
    Run Code

    Output:

    I am Programming Language.
    I am Object-Oriented Programming Language.

    In the above example, we have created an object variable  pl  of


    the  ProgrammingLanguage  class. Here,  pl  is a polymorphic variable. This is
    because,
     In statement  pl = new ProgrammingLanguage() ,  pl  refer to the object of
    the  ProgrammingLanguage  class.
     And, in statement  pl = new Java() ,  pl  refer to the object of the  Java  class.

    Java Polymorphism
    Polymorphism means "many forms", and it occurs when we have many classes
    that are related to each other by inheritance.

    Like we specified in the previous chapter; Inheritance lets us inherit attributes


    and methods from another class. Polymorphism uses those methods to
    perform different tasks. This allows us to perform a single action in different
    ways.

    For example, think of a superclass called Animal that has a method


    called animalSound(). Subclasses of Animals could be Pigs, Cats, Dogs, Birds -
    And they also have their own implementation of an animal sound (the pig oinks,
    and the cat meows, etc.):

    Example
    class Animal {

    public void animalSound() {


    System.out.println("The animal makes a sound");

    class Pig extends Animal {

    public void animalSound() {

    System.out.println("The pig says: wee wee");

    class Dog extends Animal {

    public void animalSound() {

    System.out.println("The dog says: bow wow");

    }
    Remember from the Inheritance chapter that we use the extends keyword to
    inherit from a class.

    Now we can create Pig and Dog objects and call the animalSound() method on both


    of them:

    Example
    class Animal {

    public void animalSound() {

    System.out.println("The animal makes a sound");

    }
    class Pig extends Animal {

    public void animalSound() {

    System.out.println("The pig says: wee wee");

    class Dog extends Animal {

    public void animalSound() {

    System.out.println("The dog says: bow wow");

    class Main {

    public static void main(String[] args) {

    Animal myAnimal = new Animal(); // Create a Animal object

    Animal myPig = new Pig(); // Create a Pig object

    Animal myDog = new Dog(); // Create a Dog object

    myAnimal.animalSound();

    myPig.animalSound();

    myDog.animalSound();

    You might also like