Understanding Polymorphism in Java: Compile-Time vs. Runtime Explained

Polymorphism is one of the four core concepts of Object-Oriented Programming (OOP), alongside encapsulation, inheritance, and abstraction. The term "polymorphism" means "many forms", and in Java, it allows objects to take on multiple forms depending on the context.
 
In this blog post, we'll explore:
 

• What polymorphism is
• Types of polymorphism in Java
• How compile-time and runtime polymorphism work
• Real-world examples to simplify your understanding

What is Polymorphism?

 
Polymorphism allows the same method to behave differently based on the object that calls it. This helps in writing flexible and reusable code. It enables one interface to be used for a general class of actions.
 
Java supports two types of polymorphism:
 

1. Compile-Time Polymorphism (also known as Static Polymorphism)
2. Runtime Polymorphism (also known as Dynamic Polymorphism)

1. Compile-Time Polymorphism

Definition:

 
Compile-time polymorphism is achieved using method overloading. It happens when multiple methods have the same name but different parameter lists in the same class.
 

Compile-time polymorphism, also called static polymorphism or early binding, is a feature in object-oriented programming where the method to run is decided when the program is being compiled. This usually happens through method overloading, where a class has multiple methods with the same name but different parameters (like different number, types, or order of arguments). The compiler figures out which method to use based on these differences. This lets one method name do different tasks depending on the input, making the code easier to read and reuse.

Example:

public class Calculator {
    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Overloaded method to add three integers
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

Key Characteristics:

• Resolved during compile time.
• Achieved using method overloading or operator overloading (note: Java does not support operator overloading).
• Increases code readability.

Example: NotificationSender – Sending Various Types of Notifications

 
Imagine a system that sends different types of notifications: emails, SMS, and push notifications. We can design a NotificationSender class that uses method overloading to handle these different notification types based on the parameters provided.
 

public class NotificationSender {

    // Send an email notification
    public void sendNotification(String emailAddress, String subject, String message) {
        System.out.println("Sending Email to " + emailAddress);
        System.out.println("Subject: " + subject);
        System.out.println("Message: " + message);
    }

    // Send an SMS notification
    public void sendNotification(String phoneNumber, String message) {
        System.out.println("Sending SMS to " + phoneNumber);
        System.out.println("Message: " + message);
    }

    // Send a push notification
    public void sendNotification(String deviceToken, String title, String message, boolean isPush) {
        if (isPush) {
            System.out.println("Sending Push Notification to device token: " + deviceToken);
            System.out.println("Title: " + title);
            System.out.println("Message: " + message);
        }
    }

    public static void main(String[] args) {
        NotificationSender sender = new NotificationSender();

        sender.sendNotification("user@example.com", "Welcome!", "Thank you for signing up.");
        sender.sendNotification("1234567890", "Your OTP is 4567.");
        sender.sendNotification("device_token_abc123", "Update Available", "Please update your app.", true);
    }
}

Output:

Sending Email to user@example.com
Subject: Welcome!
Message: Thank you for signing up.
Sending SMS to 1234567890
Message: Your OTP is 4567.
Sending Push Notification to device token: device_token_abc123
Title: Update Available
Message: Please update your app.

Explanation:

• Method Overloading: The sendNotification method is overloaded with different parameter lists to handle various notification types:
  • Sending an email requires an email address, subject, and message.
  • Sending an SMS requires a phone number and message.
  • Sending a push notification requires a device token, title, message, and a boolean flag to indicate it's a push notification.
• Compile-Time Polymorphism: The Java compiler determines which version of the sendNotification method to invoke based on the method signature at compile time, demonstrating compile-time polymorphism.

Benefits:

• Flexibility: Allows the NotificationSender to handle different notification types with a single method name, improving code readability.
• Maintainability: Easier to manage and extend functionalities for new notification types.
• Efficiency: Reduces the need for multiple method names, simplifying the API for developers.

2. Runtime Polymorphism

Definition:

 
Runtime polymorphism is achieved using method overriding. It occurs when a subclass provides a specific implementation of a method already defined in its superclass.

Runtime Polymorphism (also called Dynamic Polymorphism) is an important idea in object-oriented programming. It means that the program decides which version of a method to run while it’s running, based on the actual type of the object, not just the type it was declared as. This happens through method overriding, where a child class provides its own version of a method that was already defined in the parent class. This way, the program can behave differently depending on the object, making the code more flexible and adaptable.
 

Example:

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");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a;
        a = new Dog(); // a is Animal, but refers to Dog
        a.sound();     // Outputs: Dog barks

        a = new Cat();
        a.sound();     // Outputs: Cat meows
    }
}

Key Characteristics:

• Resolved during runtime.
• Achieved using method overriding.
• Relies on inheritance and the concept of upcasting.
• Enhances flexibility and enables late binding.

Example: ShapeDrawer – Drawing Different Shapes

 
In this scenario, we have a base class Shape with a method draw(), and two subclasses Circle and Rectangle that provide their specific implementations of the draw() method.
 

// Base class
class Shape {
    void draw() {
        System.out.println("Drawing a generic shape");
    }
}

// Subclass Circle
class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

// Subclass Rectangle
class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class ShapeDrawer {
    public static void main(String[] args) {
        Shape shape1 = new Circle();     // Upcasting
        Shape shape2 = new Rectangle();  // Upcasting

        shape1.draw();  // Output: Drawing a circle
        shape2.draw();  // Output: Drawing a rectangle
    }
}

Explanation:

• Method Overriding: Both Circle and Rectangle classes override the draw() method of the Shape class to provide their specific implementations.
• Upcasting: In the main method, Shape references (shape1 and shape2) are assigned objects of Circle and Rectangle, respectively. This is known as upcasting.
• Runtime Polymorphism: At runtime, the Java Virtual Machine (JVM) determines which draw() method to invoke based on the actual object type (Circle or Rectangle), not the reference type (Shape). This is the essence of runtime polymorphism.

Output:

Drawing a circle
Drawing a rectangle

 
This example illustrates how runtime polymorphism allows for flexible and dynamic method invocation, enabling the same method call (draw()) to exhibit different behaviors depending on the object's actual class.

Polymorphism in Real-World Applications

 
Imagine a payment system:
 

class Payment {
    void pay() {
        System.out.println("Processing generic payment");
    }
}

class CreditCard extends Payment {
    void pay() {
        System.out.println("Processing credit card payment");
    }
}

class PayPal extends Payment {
    void pay() {
        System.out.println("Processing PayPal payment");
    }
}

public class PaymentSystem {
    public static void makePayment(Payment payment) {
        payment.pay(); // Runtime polymorphism in action
    }

    public static void main(String[] args) {
        makePayment(new CreditCard());
        makePayment(new PayPal());
    }
}

Output:
 

Processing credit card payment  
Processing PayPal payment

Why is Polymorphism Important?

• Reusability: Write once, use many times.
• Maintainability: Easy to change behavior with minimal changes.
• Extensibility: New classes can be introduced with minimal modifications to existing code.
• Flexibility: Work with superclass types and call subclass behavior.

 Key Differences Between Compile-Time and Run-Time Polymorphism

 
Understanding the distinction between compile-time and run-time polymorphism is crucial for writing efficient and scalable Java applications. Here’s a side-by-side comparison to make it easier:

### Compile-Time vs Run-Time Polymorphism in Java

| 🔍 Feature          | 🧮 Compile-Time Polymorphism                                       | 🧠 Run-Time Polymorphism                                                      |
|---------------------|-------------------------------------------------------------------|-------------------------------------------------------------------------------|
| Binding Time        | Resolved during compilation; the method is chosen by the compiler | Resolved during runtime based on the object’s actual type                    |
| How It's Achieved   | Implemented via method overloading (same name, different params)  | Implemented via method overriding in a subclass                              |
| Performance         | Faster, as the decision is made during compile time               | Slightly slower due to dynamic method resolution                             |
| Flexibility         | Less flexible; behavior is fixed at compile time                  | More flexible; behavior depends on object type at runtime                    |
| Example Use Case    | `add(int a, int b)` vs `add(double a, double b)` methods           | Calling `pay()` on `Payment` reference for `CreditCard` or `PayPal` objects |
| Extensibility       | Harder to scale without modifying method signatures               | Easier to extend with new behaviors via inheritance                         |

Final Thought

 
Polymorphism is a cornerstone of object-oriented programming (OOP), enabling a unified interface to represent different underlying forms. This capability allows objects of various classes to be treated as instances of a common superclass, facilitating code that is more flexible and easier to maintain. 

By employing polymorphism, developers can write more generic and reusable code. For instance, a single method can operate on objects of different classes, each providing its own specific implementation. This not only reduces code duplication but also enhances the scalability of applications, as new classes can be introduced without modifying existing codebases. 

Moreover, polymorphism supports the design of modular systems where components can be developed and tested independently. This modularity leads to clearer and more maintainable code structures, as changes in one part of the system have minimal impact on others. 

In essence, mastering polymorphism empowers developers to build robust, adaptable, and efficient software systems. It embodies the principle of "programming to an interface, not an implementation," which is fundamental to creating extensible and maintainable code architectures.