Compile-time vs. Runtime Polymorphism

Hello! Welcome to your fifth lesson in our module on OOP Foundations.

In the last lesson, we explored runtime polymorphism, which is achieved through method overriding. We saw how a parent class reference can point to a child class object, and the Java Virtual Machine (JVM) dynamically chooses the correct overridden method at runtime. This is a powerful feature for creating flexible and extensible systems.

Today, we will complete your understanding of polymorphism by focusing on this lesson's learning outcome: to differentiate compile-time polymorphism (method overloading) from runtime polymorphism (method overriding). We'll explore what method overloading is, how it works, and then draw a clear line between these two fundamental concepts. This distinction is a frequent topic in technical interviews, so mastering it is essential for your preparation.

1. The Other Side of Polymorphism: Method Overloading

While method overriding allows different classes in an inheritance hierarchy to provide their own implementation of a method, method overloading allows a single class to have multiple methods with the same name, as long as they have different parameters.

This is considered a form of polymorphism because the "form" of the method call—the arguments you provide—determines which implementation is executed.

To see this in action, let's watch a short segment from the 'Coding with John' video you saw in the previous lesson.

As the video showed, the key to method overloading is the parameter list. You can overload a method by changing:

1. The number of parameters.
2. The type of parameters.
3. The order of parameters.

Crucially, you cannot overload a method by only changing its return type. The compiler wouldn't know which method to call.

Because the compiler can determine exactly which method to execute based on the arguments you provide in your code, this process is resolved at compile-time. This is why method overloading is also known as compile-time polymorphism or static binding.

2. Overloading vs. Overriding: A Detailed Comparison

Now that we have introduced both concepts, let's dive deep into their differences. Understanding these distinctions is critical for interviews. The following video provides a very thorough, point-by-point comparison from an interview perspective.

To consolidate what you've just watched, here is a summary table and a visual comparison.

Summary Table

Visual Comparison

This image provides a simple visual summary of the structural difference between the two concepts.

3. Key Interview Questions

Your understanding of this topic will almost certainly be tested in a Java LLD interview. Let's review some common questions.

Here are the key questions distilled from the reading:

• Can we override static methods?
  No. A static method with the same signature in a subclass hides the parent's method, but it is not overriding. The method that gets called is determined by the reference type at compile-time, not the object type at runtime.

• Can constructors be overloaded or overridden?
  Constructors can be overloaded (it's very common to provide multiple ways to create an object). They cannot be overridden because they are not inherited by subclasses.

• What is the difference between early (static) and late (dynamic) binding?

  • Early Binding (Static): Happens at compile-time. The compiler links a method call to a specific method body. This is used for private, final, static methods, and overloaded methods.
  • Late Binding (Dynamic): Happens at runtime. The JVM determines the method body to be executed based on the actual object type. This is used for overridden methods.

class Vehicle {
    public void move() {
        System.out.println("Vehicle is moving");
    }

    public static void stop() {
        System.out.println("Vehicle has stopped");
    }
}

class Car extends Vehicle {
    // Method 1
    @Override
    public void move() {
        System.out.println("Car is driving");
    }

    // Method 2
    public void move(int speed) {
        System.out.println("Car is driving at " + speed + " km/h");
    }

    // Method 3
    public static void stop() {
        System.out.println("Car has applied brakes");
    }

    // Method 4
    // private void move() { }
}

Conclusion

You have now covered both forms of polymorphism in Java. Understanding their distinct mechanisms and purposes is fundamental to object-oriented design.

Key Takeaways:

• Method Overloading is compile-time polymorphism (static binding). It's about providing multiple methods with the same name but different parameters within the same class for convenience.
• Method Overriding is runtime polymorphism (dynamic binding). It's about a subclass providing a specific implementation for a method defined in its superclass, requiring an identical signature.
• The choice between them is driven by purpose: overloading for flexibility in how a method is called, and overriding for flexibility in how an action is performed across a type hierarchy.

In our next lesson, we will shift our focus to a critical part of an object's life cycle. We will explain the role of constructors in object instantiation and initialization, a topic where you will see method overloading used frequently.