🌟 Introduction
In the previous articles of this series, we learned:
- What inheritance is
- Different types of inheritance in Java
Now comes one of the most important and powerful concepts in Java OOP:
👉 Method Overriding
Up to now, we saw that a child class can inherit methods from a parent class.
But what if the child class wants to change the behavior of that method?
For example:
- All animals make sound
- But dogs bark, cats meow
So the behavior is different, even though the method is the same.
This is exactly what method overriding solves.
🧠 What is Method Overriding?
Method overriding occurs when:
A child class provides its own implementation of a method that is already defined in the parent class.
In simple words:
👉 Child class replaces parent class method behavior.
🧩 Real-Life Analogy
Think of a parent class = Animal
It has a method:
makeSound()
Now:
- Dog → barks
- Cat → meows
Same method name → different behavior
👉 This is method overriding.
💻 Basic Example of Method Overriding
class Animal {
void sound() {
System.out.println("Animal makes sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
d.sound();
}
}🔎 Line-by-Line Explanation
Parent class:
class Animal
This is the base class.
Method in parent:
void sound()
This method defines a general behavior.
Child class:
class Dog extends Animal
Dog inherits from Animal.
Overridden method:
void sound()
Same method name as parent.
👉 This is method overriding.
New behavior:
System.out.println("Dog barks");
Dog changes the behavior of sound().
🧾 Output
Dog barks
👉 Parent method is not executed, child version runs.
⚙️ Important Rules of Method Overriding
✔ Rule 1: Method Name Must Be Same
void sound()
If the name changes → it is NOT overriding.
✔ Rule 2: Parameters Must Be Same
void sound()
If parameters differ → it becomes method overloading, not overriding.
✔ Rule 3: Return Type Must Be Same (or compatible)
int getValue()
Return type must match or be covariant.
✔ Rule 4: Access Modifier Rules
Child class method cannot be more restrictive.
| Parent | Child Allowed |
|---|---|
| public | public |
| protected | protected / public |
✔ Rule 5: Cannot Override Certain Methods
❌ final methods
❌ static methods
❌ private methods
🚀 Runtime Polymorphism (Most Important Concept)
This is where method overriding becomes powerful.
💻 Example
class Animal {
void sound() {
System.out.println("Animal makes sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal a = new Dog();
a.sound();
}
}🔎 Explanation
Animal a = new Dog();
👉 Reference type = Animal
👉 Object type = Dog
a.sound();
Which method will run?
👉 Output:
Dog barks
🧠 Why?
Because Java decides the method at runtime, not compile time.
This is called:
👉 Runtime Polymorphism
🏷 Using @Override Annotation
@Override
void sound() {
System.out.println("Dog barks");
}
✅ Why Use It?
✔ Avoids mistakes
✔ Ensures method is actually overridden
✔ Improves readability
⚠️ If Method is Wrong
@Override
void sounds() { }
❌ Compiler error
👉 Helps catch mistakes early
🔄 Method Overriding vs Method Overloading
| Feature | Overriding | Overloading |
|---|---|---|
| Class | Different classes | Same class |
| Method name | Same | Same |
| Parameters | Same | Different |
| Purpose | Change behavior | Multiple versions |
🧨 Tricky Interview Example
class A {
void show() {
System.out.println("Class A");
}
}
class B extends A {
void show() {
System.out.println("Class B");
}
}
public class Main {
public static void main(String[] args) {
A obj = new B();
obj.show();
}
}🧠 Output
Class B
👉 Even though reference is A, object is B.
⚠️ Common Mistakes & Confusions
❌ Mistake 1: Changing Parameters
void sound(int x)
❌ Not overriding
✔ Overloading
❌ Mistake 2: Static Methods
static void show()
❌ Static methods are not overridden
✔ They are hidden
❌ Mistake 3: Private Methods
private void show()
❌ Not inherited → cannot override
❌ Mistake 4: Thinking Compile-Time Decision
Many students think:
Method is chosen based on reference type
❌ Wrong
👉 It is chosen based on object type at runtime
❌ Mistake 5: Forgetting @Override
Leads to silent bugs.
🎯 Real-Life Example
class Vehicle {
void start() {
System.out.println("Vehicle starts");
}
}
class Car extends Vehicle {
@Override
void start() {
System.out.println("Car starts with key");
}
}
class Bike extends Vehicle {
@Override
void start() {
System.out.println("Bike starts with kick");
}
}🧠 Key Points to Remember
✔ Method overriding happens in inheritance
✔ Same method → different behavior
✔ Achieved at runtime
✔ Enables polymorphism
✔ @Override is recommended
✔ Cannot override final, static, private
🏁 Conclusion
Method overriding is one of the most powerful features of Java, allowing developers to create programs that are flexible, dynamic, and scalable.
It enables a child class to customize or replace the behavior of a parent class method, making programs more realistic and adaptable.
In this article, we covered:
- What method overriding is
- How it works
- Rules of overriding
- Runtime polymorphism
@Overrideannotation- Common mistakes and confusions
Understanding method overriding is crucial because it forms the foundation of runtime polymorphism, which is heavily used in real-world applications and interviews.
