Course contentsShow
← Java
Lesson 418 of 2,87010. Inheritance FundamentalsFree lesson

Why @Override Prevents Mistakes

See how @Override detects typos, parameter mismatches, and accidental overloading instead of overriding.

Why @Override Prevents Mistakes

What you'll learn: How the @Override annotation acts as a safety net by catching common errors when you intend to override a method.


When you override a method, you're rewriting behavior from a superclass. But it's surprisingly easy to make mistakes that prevent actual overriding—and without @Override, Java will silently accept your broken code.

The Three Common Mistakes @Override Catches

1. Typos in Method Names

If you misspell the method name, you're not overriding—you're creating a completely new method. Without @Override, the compiler stays silent:

class Animal {
    public void makeSound() { }
}

class Dog extends Animal {
    @Override
    public void makeSund() {  // Typo!
        // Compiler ERROR: method does not override from superclass
    }
}

Without @Override, makeSund() would just be a new method that nobody calls.

2. Parameter Mismatches

Wrong parameter types mean you're accidentally overloading, not overriding:

class Animal {
    public void eat(String food) { }
}

class Dog extends Animal {
    @Override
    public void eat(int food) {  // Wrong parameter type!
        // Compiler ERROR: method does not override from superclass
    }
}

3. Return Type Errors

Incompatible return types also break overriding:

class Animal {
    public String getName() { return "Animal"; }
}

class Dog extends Animal {
    @Override
    public int getName() {  // Wrong return type!
        // Compiler ERROR
    }
}

Think of It Like a Contract Inspector

@Override is like having an inspector verify your work: "You said you're overriding something—let me check that it actually exists in the superclass and matches perfectly." Without it, Java assumes you meant to create a new method.

Key Takeaway: Always use @Override when overriding methods—it turns silent failures into immediate compiler errors, saving you from debugging nightmares.