All 15 Annotations questions
More in Annotations
What are annotations in Java, and what purpose do they serve? How do you apply multiple different annotations to the same element, and does their order matter? How do you create a custom annotation in Java, and what role do @Retention and @Target play? What is the difference between compile-time annotation processing (via javax.annotation.processing.Processor) and runtime reflection-based annotation reading? What are Java's meta-annotations (@Retention, @Target, @Documented, @Inherited), and what does each control? What is the purpose of the @FunctionalInterface annotation, and is it required for an interface to actually be treated as a functional interface? How do annotations with elements (parameters) work, including default values and the special `value` element? What is the difference between the @Nullable/@NonNull annotations (from libraries like JetBrains or JSR-305) and Java's built-in Optional type for expressing nullability? How would you read custom annotations at runtime using reflection to implement annotation-driven behavior, such as a simple dependency injection or validation framework? How do repeatable annotations work in Java (using @Repeatable), and what problem do they solve?
Advertisement
Back to results for “Annotations”
Java › Annotations

What do the built-in @Override, @Deprecated, and @SuppressWarnings annotations do?

Beginner

Answer

@Override tells the compiler a method is intended to override a superclass/interface method, causing a compile error if no matching method actually exists (catching typos like a mismatched method signature); @Deprecated marks an element as discouraged for use, triggering a compiler warning at call sites and signaling to other developers (and tools) that it may be removed in the future; @SuppressWarnings suppresses specific compiler warnings (like "unchecked") for the annotated element, useful when a warning is a known, deliberately accepted trade-off.
public class Base {
    public void process() { }
}

public class Derived extends Base {
    @Override
    public void proccess() { }  // typo! Compiler catches this because @Override expects an actual override
}
Real-world example A refactor accidentally misspells an overridden method name, but because the method was marked @Override, the compiler immediately flags the error at build time rather than silently creating an unrelated new method that would have caused a confusing runtime bug.

Common follow-ups: What happens if you omit @Override but still intend to override a method -- does the code still work?;When is it appropriate to use @SuppressWarnings versus actually fixing the underlying warning?

Interfaces & Abstract Classes;OOP & Classes
All 15 Annotations questions