Polymorphism in Java Overloading Overriding

Compile-Time Polymorphism: Overloading

Overloading is selected from compile-time signatures, while overriding dispatches from the runtime object. Keeping those mechanisms separate makes polymorphic calls predictable.

A strong polymorphism example uses a parent reference such as Shape, Payment, or Notification and then calls the same method on different child objects. The result proves that runtime behavior depends on the actual object.

Overloading chooses a method at compile time based on the method name and parameter list.

Overloading

class Printer {
    void print(String text) {
        System.out.println(text);
    }

    void print(int number) {
        System.out.println(number);
    }
}

Runtime Polymorphism: Overriding

Overriding chooses the method implementation at runtime based on the actual object type.

Dynamic Dispatch

class Payment {
    void pay(double amount) {
        System.out.println("Generic payment: " + amount);
    }
}

class UpiPayment extends Payment {
    @Override
    void pay(double amount) {
        System.out.println("UPI paid: " + amount);
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Payment payment = new UpiPayment();
        payment.pay(500);
    }
}

Polymorphism with Interfaces

Interfaces make polymorphism more flexible because unrelated classes can implement the same contract.

Interface Polymorphism

interface Notifier {
    void send(String message);
}

class EmailNotifier implements Notifier {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

class SmsNotifier implements Notifier {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

Compile-Time and Runtime Polymorphism

Method overloading is resolved by the compiler using the method name and parameter list. Method overriding is resolved at runtime using the actual object type, which is why parent references can call child behavior.

Overloading means same name with different parameters.
Overriding means child class changes inherited behavior.
Runtime polymorphism supports flexible code.
Use @Override to catch mistakes.

Before you move on