Polymorphism in Java: Compile-Time vs Runtime, Method Overloading and Overriding Explained

Polymorphism is one of the core concepts of Object-Oriented Programming (OOP) in Java. It allows the same method or object to behave differently depending on the context, enabling flexibility and code reusability.

📌 What is Polymorphism?

Definition: Polymorphism means "many forms". In Java, it allows a single interface or method to represent different underlying data types or behaviors.
Why it matters: Simplifies code, enhances scalability, and supports dynamic behavior at runtime.
When to use: Whenever you want the same code to work with multiple types or provide different behavior for the same method.

[Related: link-to-other-article]

🔹 Types of Polymorphism in Java

Compile-Time Polymorphism (Static Binding): Achieved through method overloading.
Runtime Polymorphism (Dynamic Binding): Achieved through method overriding.

🔹 Compile-Time Polymorphism: Method Overloading

Definition: Multiple methods with the same name but different parameter lists within the same class.
Binding: Resolved at compile time.

💻 Example:

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 10));
        System.out.println(calc.add(5.5, 10.5));
    }
}

🔹 Runtime Polymorphism: Method Overriding

Definition: Subclass provides a specific implementation of a method already defined in the parent class.
Binding: Resolved at runtime via dynamic method dispatch.

💻 Example:

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

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

public class Main {
    public static void main(String[] args) {
        Animal obj = new Dog(); // Reference of parent, object of child
        obj.sound(); // Calls Dog's method
    }
}

🔹 Real-World Analogy

Think of polymorphism like a remote control. The same remote (method call) can control different devices (objects), and each device responds in its own way.

📊 Comparison Table

Aspect	Compile-Time Polymorphism	Runtime Polymorphism
Achieved By	Method Overloading	Method Overriding
Binding Time	Compile-Time	Runtime
Flexibility	Limited	High
Performance	Slightly faster	Slight overhead due to lookup

🚫 Common Mistakes and Anti-Patterns

❌ Confusing method overloading with overriding.
❌ Changing only return type in overloading (not allowed).
❌ Forgetting to use @Override in overriding, leading to hidden bugs.

📈 Performance and Memory Implications

Compile-time polymorphism is slightly faster due to static binding.
Runtime polymorphism has minor overhead due to dynamic method dispatch.
Both approaches save memory by reusing code and promoting abstraction.

🔧 Best Practices

Use @Override to ensure correct overriding.
Keep overloaded methods logically related.
Avoid excessive overloading that causes confusion.

📚 Interview Questions

Q: What’s the main difference between overloading and overriding?
A: Overloading is compile-time polymorphism; overriding is runtime polymorphism.
Q: Can static methods be overridden?
A: No, they are hidden, not overridden.
Q: Is method overriding possible for private methods?
A: No, private methods are not inherited.

📌 Java Version Relevance

Java Version	Change
Java 1.0	Introduced polymorphism concepts
Java 5	Added @Override annotation for safety

✅ Conclusion & Key Takeaways

Polymorphism enables flexible and reusable code.
Compile-time polymorphism uses overloading; runtime polymorphism uses overriding.
Use best practices to avoid confusion and ensure clean design.

❓ FAQ

Q: Can constructors be overloaded?
A: Yes, constructor overloading is a form of compile-time polymorphism.

Q: Does polymorphism work with variables?
A: No, polymorphism is for methods, not fields.

Q: Can final methods be overridden?
A: No, final methods cannot be overridden.