Course contentsShow
← Java
Lesson 2405 of 2,87046. AnnotationsFree lesson

@Override: Preventing Method Signature Mistakes

Learn how @Override catches typos and signature errors when overriding methods, preventing silent bugs.

@Override: Preventing Method Signature Mistakes

What you'll learn: How the @Override annotation catches method signature errors at compile time, preventing subtle bugs when you intend to override a superclass method.

The Silent Danger of Typos

When you override a method from a parent class, even a tiny mistake in the method signature—a typo in the name, wrong parameter types, or incorrect return type—means you're not actually overriding. Instead, you've accidentally created a new method. The compiler won't warn you, and your code will silently ignore your "override," potentially causing mysterious bugs.

Think of it like addressing a letter: if you misspell the street name slightly, your letter goes to the wrong house. You think you've delivered it correctly, but it never reaches the intended recipient.

How @Override Protects You

The @Override annotation is a compile-time safety net. When you mark a method with @Override, you're telling the compiler: "This method MUST override something from a parent class or interface." If the compiler can't find a matching method signature in any superclass or implemented interface, it fails the build with a clear error.

class Animal {
    public void makeSound() {
        System.out.println("Generic sound");
    }
}

class Dog extends Animal {
    @Override
    public void makesound() {  // Typo: lowercase 's'
        System.out.println("Bark");
    }
}
// Compile error: Method does not override method from its superclass

Without @Override, that code would compile fine—but makesound() would be a completely separate method, and calling makeSound() on a Dog would still print "Generic sound."

Catching Parameter Mismatches

@Override also catches parameter type errors, ensuring your signature matches exactly:

class Calculator {
    public int add(int a, int b) { return a + b; }
}

class AdvancedCalculator extends Calculator {
    @Override
    public int add(double a, double b) {  // Wrong parameter types
        return (int)(a + b);
    }
}
// Compile error: parameters don't match superclass method

Key Takeaway: Always use @Override when overriding methods—it transforms silent runtime bugs into immediate compile-time errors, catching typos and signature mismatches before they reach production.