Polymorphism: Overloading vs. Overriding

Polymorphism: The Two Flavors

Polymorphism allows us to perform a single action in different ways. In Java, this is primarily achieved through method overloading and method overriding. While they both use methods with the same name, they operate on completely different principles and at different times in a program's life cycle.

Let's start with a high-level visual comparison.

This image captures the structural difference. Now, let's explore the conceptual difference, which revolves around when the decision is made about which method to call.

The following video provides an excellent explanation of both concepts using real-life analogies—animal sounds for overriding and booking movie tickets for overloading—before diving into the code. This will help build your intuition.

As the video highlights, the core difference is about timing:

• Method Overloading is resolved at compile time. The compiler analyzes the method call (myObject.myMethod(arg1, arg2)) and matches it to the correct overloaded version based on the number and type of arguments. This is static polymorphism or early binding.
• Method Overriding is resolved at run time. The compiler only knows that you're calling a method that exists in the parent class. The Java Virtual Machine (JVM) waits until the program is running to check the actual type of the object and then calls the appropriate version of the method. This is runtime polymorphism or dynamic binding.

A Structured Comparison

To make the distinctions crystal clear, let's look at a summary table. The following article from DigitalOcean provides a concise and accurate breakdown.

Let's distill the information from that table into a few key points:

The "How": Dynamic Method Dispatch

You might be wondering how the JVM achieves runtime polymorphism. The mechanism behind it is called Dynamic Method Dispatch. This is the process that allows a superclass reference variable to refer to a subclass object and still invoke the subclass's overridden method.

Consider this classic example:

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // Superclass reference, subclass object
        myAnimal.makeSound(); // Which method is called?
    }
}

The variable myAnimal is of type Animal, but the object it points to is of type Dog. At compile time, the compiler only checks if the Animal class has a makeSound() method. It does, so the code compiles. However, at runtime, the JVM inspects the actual object (new Dog()) and sees that it has an overridden makeSound() method. Therefore, it calls the Dog's version, and the output is "Woof". This decision-making process at runtime is Dynamic Method Dispatch.

The following video from Telusko provides a fantastic walkthrough of this exact concept.

Seeing Both in Action

To tie everything together, let's examine a single piece of code that uses both overloading and overriding. The DigitalOcean article we looked at earlier provides a great example.

This example clearly shows the two concepts coexisting. Overloading provides different ways to call the process method, while overriding allows a specialized subclass like MathProcessor to change what those methods actually do.

Your Turn: A Notification System

Let's solidify your understanding with a practical exercise. You'll build a simple notification system that uses both overloading and overriding.

Task:

1. Create a base class named NotificationService.

   • It should have a method: public void send(String message). This method should print [NOTIFICATION] followed by the message.
   • Overload this method by adding another version: public void send(String subject, String message). This method should print [NOTIFICATION] Subject: <subject> - Body: <message>.

2. Create a subclass named EmailService that extends NotificationService.

   • Override the send(String message) method to print [EMAIL] Sent: followed by the message.
   • Override the send(String subject, String message) method to print [EMAIL] Sent with Subject: <subject> - Body: <message>.

3. Create another subclass named SMSService that extends NotificationService.

   • Override the send(String message) method to print [SMS] Delivered: followed by the message.
   • Override the send(String subject, String message) method. For an SMS, a subject doesn't make much sense, so have it combine them: [SMS] Delivered: <subject> - <message>.

4. Create a Main class to test your system.

   • Create an EmailService object and an SMSService object.
   • Use a NotificationService reference variable for each (upcasting):

     NotificationService emailSender = new EmailService();
     NotificationService smsSender = new SMSService();
     

   • Call both the single-parameter and two-parameter send methods on emailSender and smsSender.
   • Observe how the JVM uses runtime polymorphism to call the correct overridden methods from EmailService and SMSService, even though the reference type is NotificationService.

Summary

Today we dissected the two types of polymorphism in Java, a concept crucial for building flexible and maintainable object-oriented systems.

Key Takeaways:

• Polymorphism means "many forms"; it's the ability to perform an action in different ways.
• Method Overloading is compile-time polymorphism. It occurs within a single class, using the same method name with different parameter lists. The compiler chooses the method based on the arguments.
• Method Overriding is runtime polymorphism. It occurs in a parent-child class relationship, where the child provides a specific implementation for an inherited method. The JVM chooses the method at runtime based on the actual object's type, via Dynamic Method Dispatch.
• Overloading is about providing more options or flexibility (add(int, int), add(int, int, int)), while overriding is about changing behavior (Animal.speak() vs. Dog.speak()).

In our next lesson, we'll build directly on the idea of NotificationService sender = new EmailService();. We will formally explore upcasting, its counterpart downcasting, and how to safely check an object's type at runtime using the instanceof operator.