Method Overloading & Overriding in Java
In Java, Method Overloading and Method Overriding are core OOP concepts used to achieve Polymorphism — the ability of a method to behave differently based on context. Both make programs flexible, readable, and reusable.
What is Method Overloading (Compile-Time Polymorphism)?
Occurs within the same class, when multiple methods have the same name but different parameters (type, number, or order).
-
Decision made at compile time → Compile-time polymorphism.
Syntax
class Calculator {
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
}Example – Method Overloading
public class OverloadingExample {
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("Sum (int): " + calc.add(10, 20));
System.out.println("Sum (double): " + calc.add(5.5, 4.5));
System.out.println("Sum (3 ints): " + calc.add(1, 2, 3));
}
}
Output:
Sum (int): 30
Sum (double): 10.0
Sum (3 ints): 6Points About Overloading
- Must have different parameter list (number, type, order).
- Can have different return types (if parameter list differs).
- Can overload constructors.
- Happens within the same class.
- Compile-time polymorphism.
Example – Constructor Overloading
class Student {
String name; int age;
Student(String name) { this.name = name; }
Student(String name, int age) { this.name = name; this.age = age; }
void show() { System.out.println(name + " - " + age); }
}
public class ConstructorOverloading {
public static void main(String[] args) {
Student s1 = new Student("Aman");
Student s2 = new Student("Neha", 20);
s1.show(); s2.show();
}
}
Output:
Aman - 0
Neha - 20
What is Method Overriding (Runtime Polymorphism) ?
Occurs between parent and child classes, when a subclass provides a new implementation of a method already defined in its superclass.
-
Decision made at runtime → Runtime polymorphism.
Syntax
class Parent { void show() { ... } }
class Child extends Parent { @Override void show() { ... } }Example – Method Overriding
class Animal {
void sound() { System.out.println("Some sound"); }
}
class Dog extends Animal {
@Override
void sound() { System.out.println("Dog barks"); }
}
public class OverridingExample {
public static void main(String[] args) {
Animal a = new Dog(); // Upcasting
a.sound(); // Calls Dog's version
}
}
Output:
Dog barks
Points About Overriding
- Must have the same method name, parameters, and return type.
- Must be in subclass (inheritance required).
- The
@Overrideannotation is optional but recommended. - The access level cannot be more restrictive than the parent.
- Static, private, or final methods cannot be overridden.
- Decision made at runtime → Runtime polymorphism.
Example – Using super Keyword
class Parent {
void display() { System.out.println("Display from Parent"); }
}
class Child extends Parent {
@Override
void display() {
super.display(); // call parent method
System.out.println("Display from Child");
}
}
public class SuperExample {
public static void main(String[] args) {
Child obj = new Child();
obj.display();
}
}Output:
Display from Parent
Display from Child
Difference Between Overloading and Overriding
| Feature | Method Overloading | Method Overriding |
|---|---|---|
| Definition | Same method name, different parameters (same class) | Same method name & parameters (subclass redefines) |
| Polymorphism Type | Compile-time | Runtime |
| Parameters | Must differ | Must be same |
| Return Type | Can differ (if parameter list changes) | Must be same or covariant |
| Access Modifier | Can change | Can’t be more restrictive |
| Static/Final Methods | Can overload | Cannot override |
| Keyword Used | — | @Override |
| Occurs In | Same class | Parent–child classes |
When to Use Which
| Scenario | Use |
|---|---|
| Multiple ways to perform similar operations | Overloading |
| Modify inherited behavior | Overriding |
| Polymorphic behavior with inheritance | Overriding |