Polymorphism: Upcasting and Dynamic Dispatch

1. Upcasting: Viewing an Object Through a More General Lens

Before we can see polymorphism in action, we need to understand a prerequisite concept called upcasting. In simple terms, upcasting is the process of treating an object of a subclass as an object of its superclass. Because a subclass instance is-a superclass instance (a Dog is an Animal), this is a perfectly safe and implicit operation in Java.

The syntax for upcasting involves assigning a new subclass object to a reference variable of the superclass type.

Let's see this with a code example. The Baeldung article "Upcasting vs. Downcasting in Java" provides a clear definition and an initial example.

As the article demonstrates, when you upcast, the object you create is still a Dog in memory, but the "handle" you are using to interact with it (myDog) is of type Animal. This has a critical consequence: the reference type determines which methods are available to call at compile time.

Let's refine the example from the article:

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

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

    public void fetch() {
        System.out.println("Dog fetches the ball");
    }
}

public class Main {
    public static void main(String[] args) {
        // This is upcasting
        Animal myAnimal = new Dog(); 
        
        // This is valid because makeSound() is defined in the Animal class.
        myAnimal.makeSound(); 

        // This would cause a COMPILE ERROR.
        // myAnimal.fetch(); // The compiler says: "The method fetch() is undefined for the type Animal."
    }
}

The compiler only "sees" the Animal reference type, which doesn't have a fetch() method. It prevents you from calling it. So, if upcasting restricts us, why is it so useful? It's because it enables dynamic method dispatch.

2. Dynamic Method Dispatch: How Java Achieves Runtime Polymorphism

Dynamic Method Dispatch is the mechanism that resolves a call to an overridden method at runtime rather than at compile time. When you call a method on an object through a superclass reference, the JVM checks the actual type of the object in memory and executes the method belonging to that specific object.

The Telusko channel has an excellent video that breaks this down.

As the video clearly shows, the decision of which show() method to call is made at runtime, depending on whether the obj reference is pointing to an object of type A, B, or C. This is runtime polymorphism.

3. A Practical Example and Its Implications

Let's solidify this with another clear, text-based example that you can study and refer back to.

This ability to write code against a general superclass and have it work correctly with any number of specific subclasses is a cornerstone of good object-oriented design. It allows you to build systems that are easily extensible. Imagine you have a method performSound(Animal animal). You could pass any object that extends Animal to it (Dog, Cat, Lion, etc.), and the method would work without any changes.

However, as the article points out, if a method is not overridden in the subclass, the superclass's version is simply inherited and executed. Dynamic dispatch only applies to methods that are actually overridden.

4. Why It's Called Dynamic Binding: The Role of static

In the previous lesson, we touched on compile-time (static) versus runtime (dynamic) polymorphism. Now we can see exactly why dynamic dispatch is a form of runtime polymorphism. The binding of the method call to the method body happens dynamically at runtime.

This does not apply to all methods. Methods that are private, final, or, most importantly, static are resolved at compile time. This is called static binding. Since static methods belong to the class, not the object instance, the compiler binds the call based on the reference type, not the runtime object type.

This is a frequent interview question, and understanding the distinction is vital.

Conclusion

In this lesson, we have seen how method overriding enables one of the most powerful features of OOP: runtime polymorphism. This allows for the creation of flexible and extensible code where decisions about behavior are deferred until runtime.

Here are the key takeaways:

• Upcasting is the implicit casting of a subclass object to a superclass reference. It's what makes runtime polymorphism possible in this context.
• Dynamic Method Dispatch is the runtime mechanism where the JVM selects the appropriate overridden method based on the object's actual type, not the reference's type.
• The reference type determines which methods you are allowed to call (a compile-time check).
• The object's actual type determines which implementation of an overridden method gets executed (a runtime check).
• Instance methods use dynamic binding, while static, final, and private methods use static binding.

We've focused on how to handle different object types through a common superclass. But what if the superclass itself is too general to be instantiated? What if it's merely a "blueprint" that defines a contract for its subclasses? In our next lesson, we will explore this idea by delving into abstract classes and methods.