Java - Polymorphism

 Polymorphism in Java

Polymorphism is a core concept of Object-Oriented Programming (OOP) in Java. The term "polymorphism" is derived from the Greek words "poly" (many) and "morph" (forms), meaning "many forms." In Java, polymorphism allows objects to take multiple forms and enables developers to write flexible, reusable, and maintainable code. It allows the same interface or method to behave differently based on the object that invokes it. This concept is widely used in frameworks, libraries, API design, and large-scale application development.

What is Polymorphism in Java?

Polymorphism in Java allows an object to behave differently in different contexts. In simpler terms, a single method, class, or interface can take multiple forms. This concept is essential for achieving dynamic behavior in Java programs. Polymorphism is broadly categorized into two types in Java:

• Compile-time Polymorphism (Static Polymorphism)
• Runtime Polymorphism (Dynamic Polymorphism)

Key Characteristics of Polymorphism

• Method overloading and overriding are the main ways to achieve polymorphism.
• It promotes flexibility in code.
• Encourages code reusability and modularity.
• Enables dynamic method invocation at runtime.
• Supports abstraction and inheritance in OOP.

Types of Polymorphism in Java

1. Compile-Time Polymorphism (Static Polymorphism)

Compile-time polymorphism occurs when the method to be invoked is determined at compile time. It is mainly achieved through **method overloading** and **operator overloading** (though Java supports limited operator overloading).

Method Overloading

Method overloading allows multiple methods in the same class to have the same name but different parameter lists (number, type, or order of parameters). The compiler determines which method to call based on the method signature.

Example of Method Overloading

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

class Test {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 10));
        System.out.println(calc.add(3.5, 2.5));
        System.out.println(calc.add(1, 2, 3));
    }
}

Advantages of Compile-Time Polymorphism

• Improves code readability.
• Supports multiple methods with similar functionality.
• Increases maintainability by avoiding method name redundancy.

2. Runtime Polymorphism 

Runtime polymorphism occurs when the method to be invoked is determined at runtime. It is achieved through **method overriding** and relies on inheritance and dynamic method dispatch. Dynamic polymorphism allows a parent class reference to refer to a child class object and invoke overridden methods.

Method Overriding

Method overriding allows a subclass to provide a specific implementation of a method that is already defined in its parent class. The overridden method must have the same name, return type, and parameters. The access modifier of the overriding method cannot be more restrictive than the overridden method.

Example of Method Overriding

class Vehicle {
    void run() {
        System.out.println("Vehicle is running");
    }
}

class Car extends Vehicle {
    @Override
    void run() {
        System.out.println("Car is running smoothly");
    }
}

class Bike extends Vehicle {
    @Override
    void run() {
        System.out.println("Bike is running fast");
    }
}

class Test {
    public static void main(String[] args) {
        Vehicle v1 = new Car();
        Vehicle v2 = new Bike();
        
        v1.run();
        v2.run();
    }
}

Advantages of Runtime Polymorphism

• Enables dynamic behavior at runtime.
• Supports loose coupling and modular design.
• Promotes code extensibility and maintainability.
• Encourages the use of abstract classes and interfaces.

Polymorphism with Interfaces

Interfaces in Java are used to achieve full abstraction and runtime polymorphism. A single interface reference can point to multiple implementation classes at runtime, which allows developers to write flexible and decoupled code.

Example: Polymorphism with Interface

interface Payment {
    void pay(int amount);
}

class CreditCard implements Payment {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card");
    }
}

class UPI implements Payment {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using UPI");
    }
}

class Test {
    public static void main(String[] args) {
        Payment p;
        
        p = new CreditCard();
        p.pay(500);
        
        p = new UPI();
        p.pay(1000);
    }
}

Polymorphism with Abstract Classes

Abstract classes allow runtime polymorphism by letting a parent class reference point to subclass objects. Abstract methods in the parent class are overridden by subclasses, which ensures dynamic method invocation.

Example: Polymorphism with Abstract Class

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing Circle");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("Drawing Rectangle");
    }
}

class Test {
    public static void main(String[] args) {
        Shape s;
        
        s = new Circle();
        s.draw();
        
        s = new Rectangle();
        s.draw();
    }
}

Polymorphism and Dynamic Method Dispatch

Dynamic method dispatch is a mechanism by which a call to an overridden method is resolved at runtime rather than compile-time. This is the foundation of runtime polymorphism in Java. It allows one reference variable to point to multiple objects of different types at different times.

Example: Dynamic Method Dispatch

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

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

class Cat extends Animal {
    void sound() {
        System.out.println("Cat meows");
    }
}

class Test {
    public static void main(String[] args) {
        Animal a;
        
        a = new Dog();
        a.sound();
        
        a = new Cat();
        a.sound();
    }
}

Advantages of Polymorphism in Java

• Improves code readability and maintainability.
• Enables method reusability through overloading and overriding.
• Supports dynamic behavior at runtime.
• Encourages decoupled, modular programming.
• Reduces complexity in large-scale applications.
• Promotes the use of interfaces and abstract classes.
• Facilitates extensible and scalable software design.

Disadvantages of Polymorphism

• Overuse can make code confusing for beginners.
• Dynamic polymorphism may incur a slight performance overhead due to runtime resolution.
• Requires proper understanding of inheritance and object references.
• Incorrect design can lead to fragile architectures.

Polymorphism Best Practices in Java

• Use method overloading judiciously for readability.
• Use method overriding to provide specialized behavior in subclasses.
• Prefer interfaces for loose coupling and flexibility.
• Keep class hierarchies simple and logical.
• Follow SOLID principles for maintainable design.
• Test dynamic polymorphic behavior carefully.
• Use polymorphism in frameworks, APIs, and library design for extensibility.

Use Cases of Polymorphism

• Designing frameworks and libraries.
• API and SDK development.
• Banking and payment systems (e.g., multiple payment modes).
• Game development (e.g., different types of characters or weapons).
• Mobile and web application modularization.
• Enterprise-level software systems with plugin architectures.
• Graphical user interface systems (different components with shared methods).

Example: Polymorphism in Real-World Application

interface Notification {
    void notifyUser(String message);
}

class EmailNotification implements Notification {
    public void notifyUser(String message) {
        System.out.println("Email sent: " + message);
    }
}

class SMSNotification implements Notification {
    public void notifyUser(String message) {
        System.out.println("SMS sent: " + message);
    }
}

class Test {
    public static void main(String[] args) {
        Notification n;
        
        n = new EmailNotification();
        n.notifyUser("Welcome to Java Learning Platform!");
        
        n = new SMSNotification();
        n.notifyUser("Your OTP is 1234");
    }
}

Java Polymorphism is a foundational OOP concept that provides flexibility, modularity, and scalability in programming. Through method overloading, overriding, interfaces, and abstract classes, polymorphism enables objects and methods to take multiple forms and behave dynamically. Understanding and implementing polymorphism correctly improves code maintainability, promotes clean design, and prepares developers to build enterprise-level applications and frameworks. Mastering polymorphism is a critical step in becoming an advanced Java programmer and writing efficient, reusable, and dynamic Java code.