Java @Override Annotation

Introduction

The @Override annotation in Java indicates that a method is intended to override a method in a superclass. It helps ensure that the method correctly overrides the superclass method.

Table of Contents

1. What is @Override?
2. Benefits of Using @Override
3. How to Use @Override
4. Examples
5. Conclusion

1. What is @Override?

@Override is an annotation used to signify that a method is overriding a method in its superclass. It provides compile-time checking to ensure the method signature matches.

2. Benefits of Using @Override

• Compile-Time Checking: Ensures the method signature matches the overridden method.
• Readability: Makes the code clearer and easier to understand.
• Maintenance: Helps prevent errors during code refactoring.

3. How to Use @Override

To use @Override, simply place the annotation above the method that overrides a method from the superclass.

4. Examples

Example 1: Correct Usage of @Override

This example demonstrates using @Override to correctly override a method.

class Animal { void sound() { System.out.println("Animal sound"); } } class Dog extends Animal { @Override void sound() { System.out.println("Bark"); } } public class OverrideExample { public static void main(String[] args) { Dog dog = new Dog(); dog.sound(); // Output: Bark } } 

Example 2: Compile-Time Error Without @Override

This example shows how @Override can help catch errors during compilation.

class Bird { void fly() { System.out.println("Flying"); } } class Sparrow extends Bird { @Override void flly() { // Typo in method name System.out.println("Sparrow flying"); } } public class OverrideErrorExample { public static void main(String[] args) { Sparrow sparrow = new Sparrow(); sparrow.fly(); // Output: Flying } } 

In this example, a compile-time error will occur because flly() does not override fly() due to the typo.

5. Conclusion

The @Override annotation in Java is a valuable tool for ensuring that methods are correctly overridden. It enhances code readability, maintainability, and helps catch errors during compilation, making it an essential practice in Java development.