Polymorphism | Notion

Introduction to Polymorphism

Polymorphism is one of the core concepts of object-oriented programming (OOP) in Java.

→ It allows objects to be treated as instances of their parent class rather than their actual class.

→ The word "polymorphism" is derived from the Greek words "poly" (meaning many) and "morph" (meaning form), signifying the ability to take many forms.

In Java, polymorphism is primarily achieved through method overriding and method overloading. It allows for flexibility and the ability to extend functionality by enabling objects to be manipulated regardless of their specific class types.

Types of Polymorphism

Compile-time Polymorphism (Static Polymorphism)
- Achieved by method overloading and operator overloading.
- The method to be called is resolved at compile time.
- Examples include method overloading and constructor overloading.
- Method Overloading: Multiple methods with the same name but different parameters.
- Constructor Overloading: Multiple constructors with different parameter lists in a class.
Example of Method Overloading:
```
class MathOperations {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}
```
Runtime Polymorphism (Dynamic Polymorphism)
- Achieved by method overriding.
- The method to be called is resolved at runtime.
- It allows a subclass to provide a specific implementation of a method that is already defined in its superclass.
- Method Overriding: A subclass provides a specific implementation of a method that is already defined in its parent class.
Example of Method Overriding:
```
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound(); // Outputs: Dog barks
    }
}
```

Advantages of Polymorphism

Flexibility: Allows the use of a single interface to represent different underlying forms (data types).
Maintainability: Easier to maintain and modify the code.
Extensibility: New functionality can be easily added with minimal changes to the existing codebase.
Reusability: Promotes the reuse of code by implementing methods defined in the parent class.

Diagrams

Method Overloading (Compile-time Polymorphism)

              +-------------------+
              | MathOperations    |
              +-------------------+
              | - add(int, int)   |
              | - add(double, double) |
              +-------------------+

Method Overriding (Runtime Polymorphism)

          +-------------------+                   +-------------------+
          |      Animal       |                   |        Dog        |
          +-------------------+                   +-------------------+
          | - sound()         |<-- overridden --  | - sound()         |
          +-------------------+                   +-------------------+