When do you use Java's @Override annotation and why?

Question

What are the best practices for using Java's `@Override` annotation and why? It seems like it would be overkill to mark every single overridden method with the `@Override` annotation. Are there certain programming situations that call for using the `@Override` and others that should never use the `@Override`?

Answer 1

Based on the question, I'm going to assume some prior knowledge of overriding methods and how that works, but if not here's a quick rundown.

The answer lies almost entirely in the access modifier of the method being overridden and the relationship between the subclass and the parent class. The "@Override" annotation is an example of run time polymorphism and can be used in a subclass to override a method with the same signature in the parent class, allowing the compiler to execute the overriden method in the subclass. But there are situations in which it works fine, may not work as intended, or may induce an error depending on scope, return type inheritance, or static, private, or final modifiers.

The annotation itself is not necessary at all, since a method with identical signature in the subclass will supersede the method of the parent class, but it does provide some nice features at runtime that help with tracing output when errors arise. Mostly it keeps you from shooting yourself in the foot. The @Override annotation will make sure that there is a method in the parent class that exists to be overwritten, and errors will appear if you try overriding something that isn't there at all, and code will not be compiled until the errors are resolved.