Explore Topics
1
🔄 Method Overloading
One name, many parameter signatures — resolved at compile time
🔄
Method Overloading
One name, many parameter signatures — resolved at compile time
Polymorphism means "one name with many forms." Compile-time polymorphism (static binding) occurs when the compiler determines which method to call based on the method signature at compile time. Method overloading lets a class define multiple methods with the same name but different parameter lists — varying in number, type, or order of parameters. The compiler matches the call to the correct overload during compilation, so there is zero runtime overhead.
🔍 Binding Resolver — Compile-Time vs Runtime
calc.add(10, 20)
Compile-Time Track
Reference: Calculator
Checks method signature against reference type's methods
Runtime Track
Actual Object: Calculator
JVM checks actual object type for method dispatch
Key Ideas
- Polymorphism = "poly" (many) + "morph" (forms)
- Method overloading = same name, different parameter signatures
- Parameters can vary in number, type, or order
- Resolved at COMPILE TIME (static binding / early binding)
- No runtime overhead — the JVM knows exactly which method to call
- Return type alone does NOT make a valid overload
Strengths
- ✦Clean API — one intuitive method name for related operations
- ✦Type safety enforced at compile time — no guessing at runtime
- ✦Zero performance overhead compared to dynamic dispatch
- ✦Enables fluent APIs and builder patterns
Weaknesses
- △Too many overloads can confuse callers (which one will be called?)
- △Auto-widening (int→double) can cause unexpected overload resolution
- △Cannot overload by return type alone — compiler can't disambiguate
- △Default parameter values (like in Kotlin/Python) often cleaner than many overloads
Used in:
REAL-WORLD System.out.println() has 10 overloads (int, double, String, Object...). String.valueOf() similarly overloads for every primitive type.
Code Examples
Each topic has a self-contained Java example. Switch between topics above, then click the Code tab to explore line-by-line.
Quiz
Method Overloading Quiz
QUIZ 1/10Which of these is NOT a valid way to overload a method?
Signature Rules Quiz
QUIZ 2/10What is a method signature in Java?
Constructor Overloading Quiz
QUIZ 3/10What must be true about this() in a constructor?
Method Overriding Quiz
QUIZ 4/10Animal a = new Dog(); a.speak(); a.breathe();
What does this code print?
Covariant Returns Quiz
QUIZ 5/10If a parent method returns Animal, which return type is valid for an overriding method?
Static Method Hiding Quiz
QUIZ 6/10Parent ref = new Child(); ref.greet(); // static method ref.introduce(); // instance method
What does this code print?
Private Method Rules Quiz
QUIZ 7/10What happens if a child class defines a method with the same signature as a parent's private method?
Upcasting Quiz
QUIZ 8/10Vehicle v = new ElectricCar(); v.start();
What does this code print?
Downcasting Quiz
QUIZ 9/10When does a downcast throw ClassCastException?
The final Keyword Quiz
QUIZ 10/10Why can't constructors be declared final?
Diagrams
Practice Exercises
Classify each concept as Compile-Time or Runtime polymorphism:
EXERCISE 1/3Method overloading
Method overriding
Constructor overloading
Dynamic method dispatch
Static binding
Auto-widening resolution
Compile-Time (Static Binding)
Runtime (Dynamic Binding)
For each scenario, determine the outcome:
EXERCISE 2/3Vehicle v = new Car()
(Car) vehicleRef — actual is Car
(Car) vehicleRef — actual is Bus
parentRef.staticMethod()
parentRef.instanceMethod()
Override a final method
Always Safe / Succeeds
Uses Reference Type
Uses Actual Object Type
Error (Compile or Runtime)
Match each method resolution mechanism to its description:
EXERCISE 3/3Method Overloading
Method Overriding
Static Method Hiding
Private Method Binding
Compiler picks by parameter signature
JVM picks by actual object type at runtime
Compiler picks by reference type (static)
Compiler picks by declaring class (invisible to children)