Method overriding in Java - Deep Dive

Overview - Method overriding

What is it?

Method overriding is when a child class provides its own version of a method that already exists in its parent class. This means the child class changes or extends the behavior of that method. It allows objects to use the child class's method instead of the parent's when called. This is a key part of making programs flexible and reusable.

Why it matters

Without method overriding, every class would have to write all its own methods from scratch, even if they mostly do the same thing. Overriding lets programmers change only what needs to be different, saving time and reducing errors. It also allows programs to decide at runtime which method to use, making software more dynamic and adaptable.

Where it fits

Before learning method overriding, you should understand classes, inheritance, and methods in Java. After mastering overriding, you can explore polymorphism, abstract classes, and interfaces, which build on this concept to create powerful object-oriented designs.

Mental Model

Core Idea

Method overriding lets a child class replace a parent's method to customize behavior while keeping the same method name and signature.

Think of it like...

It's like a family recipe passed down from parent to child, but the child changes some ingredients to make it their own special version.

Parent Class
┌───────────────┐
│ method()     │
└─────┬─────────┘
      │
      ▼
Child Class
┌───────────────┐
│ method()     │  <-- overrides parent's method
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding inheritance basics

Concept: Inheritance allows one class to get properties and methods from another class.

In Java, a class can inherit from another using the 'extends' keyword. The child class automatically has the methods and variables of the parent class, so you don't have to rewrite them.

Result

Child class can use parent class methods without writing them again.

Knowing inheritance is essential because method overriding only works when a child class inherits from a parent.

2

Foundation

What is a method in Java

Concept: A method is a block of code that performs a task and can be called by name.

Methods have a name, return type, and parameters. For example, 'void greet()' is a method that prints a greeting. Methods help organize code into reusable pieces.

Result

You can call methods to perform actions multiple times without rewriting code.

Understanding methods is crucial because overriding changes how inherited methods behave.

3

Intermediate

How method overriding works

🤔Before reading on: do you think overriding requires changing the method name or just the code inside? Commit to your answer.

Concept: Overriding means the child class writes a method with the exact same name and parameters as the parent to change its behavior.

If the parent has 'void speak()', the child can write its own 'void speak()' method. When called on a child object, the child's version runs instead of the parent's.

Result

Child class method replaces parent's method when called on child objects.

Knowing the method signature must match exactly prevents common bugs where overriding doesn't happen.

4

Intermediate

Using @Override annotation

🤔Before reading on: do you think @Override is required or optional? Commit to your answer.

Concept: The @Override annotation tells the compiler you intend to override a method, helping catch mistakes.

If you write @Override above a method, Java checks if it really overrides a parent method. If not, it gives an error. This prevents typos or wrong method signatures.

Result

Compiler helps ensure correct overriding, reducing bugs.

Using @Override is a best practice that saves debugging time and clarifies code intent.

5

Intermediate

Overriding and access modifiers

🤔Before reading on: can a child class make an overridden method more private than the parent? Commit to your answer.

Concept: When overriding, the child method cannot be less accessible than the parent method.

If the parent method is public, the child method must be public too. You cannot override a public method with a private one because it would break access rules.

Result

Access levels stay consistent or become more open in overriding.

Understanding access rules prevents errors and maintains program security and design.

6

Advanced

Overriding and runtime polymorphism

🤔Before reading on: do you think the method called depends on the variable type or the actual object type at runtime? Commit to your answer.

Concept: Java decides which overridden method to call based on the actual object's class at runtime, not the variable's declared type.

If a parent class variable points to a child object, calling an overridden method runs the child's version. This is called dynamic method dispatch or runtime polymorphism.

Result

Programs can behave differently depending on the actual object, enabling flexible designs.

Knowing this runtime behavior is key to understanding how Java supports flexible and reusable code.

7

Expert

Limitations and surprises in overriding

🤔Before reading on: can static methods be overridden like instance methods? Commit to your answer.

Concept: Static methods cannot be overridden; they are hidden instead. Also, constructors cannot be overridden.

Static methods belong to the class, not objects, so overriding doesn't apply. If a child defines a static method with the same signature, it hides the parent's method. Also, private methods are not overridden because they are not visible to child classes.

Result

Understanding these exceptions prevents confusion and bugs in complex inheritance.

Knowing what cannot be overridden helps avoid mistaken assumptions and design errors.

Under the Hood

At runtime, when a method is called on an object, Java looks up the actual class of the object and uses its method implementation. This is done via a method table (vtable) that maps method calls to the correct code. Overridden methods replace the parent's entry in this table for the child class, enabling dynamic dispatch.

Why designed this way?

This design allows Java to support polymorphism, letting programs decide behavior dynamically. It balances flexibility with performance by using method tables instead of slower lookups. Alternatives like static binding would limit flexibility, while slower dynamic lookups would reduce speed.

Object Reference
   │
   ▼
┌─────────────┐
│ Child Object│
│ vtable ─────┼─────> Method implementations
│             │      ┌───────────────┐
└─────────────┘      │ childMethod() │
                     └───────────────┘
                     │ parentMethod()│
                     └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does overriding change the method signature or just the method body? Commit to your answer.

Common Belief: Overriding means changing the method signature to make it different.

Reality: Overriding requires the exact same method signature; only the method body changes.

Why it matters: Changing the signature creates a new method (overloading), not overriding, leading to unexpected behavior.

Quick: Can private methods be overridden? Commit to yes or no.

Common Belief: Private methods can be overridden like public methods.

Reality: Private methods are not visible to child classes and cannot be overridden.

Why it matters: Trying to override private methods causes confusion because the child defines a new method instead, which can cause bugs.

Quick: Are static methods overridden at runtime? Commit to yes or no.

Common Belief: Static methods behave like instance methods and are overridden.

Reality: Static methods are hidden, not overridden, and the method called depends on the reference type, not the object.

Why it matters: Misunderstanding this leads to bugs where the wrong static method runs unexpectedly.

Quick: Does the variable type or object type decide which overridden method runs? Commit to your answer.

Common Belief: The variable's declared type decides which method runs.

Reality: The actual object's class at runtime decides which overridden method runs.

Why it matters: This dynamic dispatch is key to polymorphism; misunderstanding it breaks flexible design.

Expert Zone

1

Overriding methods can call the parent's version using 'super.method()', allowing extension rather than replacement.

2

Final methods cannot be overridden, which enforces immutability of behavior in subclasses.

3

Covariant return types allow an overridden method to return a subtype of the parent's return type, adding flexibility.

When NOT to use

Avoid overriding when the method behavior must remain consistent across all subclasses; use 'final' methods instead. For unrelated classes sharing behavior, prefer interfaces or composition over inheritance and overriding.

Production Patterns

In real-world Java, overriding is used to implement polymorphic behavior in frameworks like Spring, where base classes define generic methods and subclasses customize them. It's also common in GUI event handling, where base event methods are overridden to respond to user actions.

Connections

Polymorphism

Method overriding enables runtime polymorphism by deciding method calls based on object type.

Understanding overriding is essential to grasp how polymorphism allows flexible and dynamic program behavior.

Interface implementation

Overriding is similar to implementing interface methods but differs because interfaces have no method bodies.

Knowing overriding clarifies how classes fulfill contracts defined by interfaces through method definitions.

Biology - Genetic inheritance

Overriding resembles how offspring inherit traits but can express them differently than parents.

Seeing overriding as biological inheritance helps appreciate how child classes customize inherited behavior.

Common Pitfalls

#1 Overriding with a different method signature

Wrong approach:

class Parent {
void show() {}
}
class Child extends Parent {
void show(int x) {} // tries to override but changes signature
}

Correct approach:

class Parent {
void show() {}
}
class Child extends Parent {
@Override
void show() {} // correct overriding
}

Root cause:

Confusing method overloading (different signature) with overriding (same signature).

#2 Overriding a private method expecting polymorphism

Wrong approach:

class Parent {
private void secret() {}
}
class Child extends Parent {
void secret() {} // not overriding, new method
}

Correct approach:

class Parent {
protected void secret() {}
}
class Child extends Parent {
@Override
void secret() {} // properly overrides
}

Root cause:

Not realizing private methods are invisible to subclasses and cannot be overridden.

#3 Using static methods expecting overriding behavior

Wrong approach:

class Parent {
static void greet() { System.out.println("Parent"); }
}
class Child extends Parent {
static void greet() { System.out.println("Child"); }
}
Parent p = new Child();
p.greet(); // prints Parent, not Child

Correct approach:

class Parent {
void greet() { System.out.println("Parent"); }
}
class Child extends Parent {
@Override
void greet() { System.out.println("Child"); }
}
Parent p = new Child();
p.greet(); // prints Child

Root cause:

Misunderstanding that static methods belong to classes, not instances, so they are hidden, not overridden.

Key Takeaways

Method overriding lets child classes provide their own version of a parent's method using the same name and parameters.

It enables dynamic behavior in programs by deciding at runtime which method to call based on the actual object.

The @Override annotation helps catch mistakes and clarifies intent when overriding methods.

Static and private methods are exceptions and cannot be overridden like instance methods.

Understanding overriding is essential for mastering polymorphism and writing flexible, reusable Java code.