11 Java Annotations Explained
Java annotations are a form of metadata that provide information about the code without changing its behavior. They are used to convey additional information to the compiler, tools, or runtime environments. Understanding these annotations is crucial for developing robust and maintainable Java SE 11 applications.
Key Concepts
1. @Override
The @Override
annotation is used to indicate that a method is intended to override a method in a superclass. It helps the compiler verify that the method signature matches the one in the superclass.
Example
class Parent { void show() { System.out.println("Parent's show()"); } } class Child extends Parent { @Override void show() { System.out.println("Child's show()"); } }
2. @Deprecated
The @Deprecated
annotation marks a method, class, or field as deprecated. It indicates that the element should no longer be used and may be removed in future versions.
Example
@Deprecated public void oldMethod() { System.out.println("This method is deprecated."); }
3. @SuppressWarnings
The @SuppressWarnings
annotation is used to suppress compiler warnings for a specific block of code. It helps in managing warnings that are deemed safe to ignore.
Example
@SuppressWarnings("unchecked") List<String> list = (List<String>) new ArrayList();
4. @FunctionalInterface
The @FunctionalInterface
annotation is used to indicate that an interface is intended to be a functional interface. It ensures that the interface has exactly one abstract method.
Example
@FunctionalInterface interface MyFunctionalInterface { void doSomething(); }
5. @SafeVarargs
The @SafeVarargs
annotation is used to suppress unchecked warnings related to varargs (variable-length argument lists). It is typically used in methods that handle varargs safely.
Example
@SafeVarargs public final void display(List<String>... lists) { for (List<String> list : lists) { System.out.println(list); } }
6. @Retention
The @Retention
annotation specifies how long annotations with the annotated type are to be retained. It can be retained at compile time, runtime, or source level.
Example
@Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation { String value(); }
7. @Target
The @Target
annotation specifies the kinds of program elements to which an annotation type is applicable. It can be applied to classes, methods, fields, etc.
Example
@Target(ElementType.METHOD) @interface MyMethodAnnotation { String value(); }
8. @Documented
The @Documented
annotation indicates that elements using the annotated type should be documented by JavaDoc and similar tools.
Example
@Documented @interface MyDocAnnotation { String value(); }
9. @Inherited
The @Inherited
annotation indicates that the annotation type can be inherited from the superclass. This is not true by default.
Example
@Inherited @interface MyInheritedAnnotation { String value(); }
10. @Repeatable
The @Repeatable
annotation indicates that the annotation type can be applied more than once to the same declaration or type use.
Example
@Repeatable(MyRepeatableAnnotations.class) @interface MyRepeatableAnnotation { String value(); } @interface MyRepeatableAnnotations { MyRepeatableAnnotation[] value(); }
11. @Native
The @Native
annotation is used to indicate that a field is a constant that may be referenced from native code. It is typically used in conjunction with JNI (Java Native Interface).
Example
class NativeExample { @Native static final int CONSTANT = 42; }
Examples and Analogies
Think of annotations as sticky notes attached to your code. Each sticky note (annotation) provides additional information or instructions to the compiler, tools, or runtime environment. For example, the @Override
annotation is like a sticky note that says, "This method is supposed to replace a method in the parent class." The @Deprecated
annotation is like a sticky note that warns, "This method is old and shouldn't be used anymore."
By mastering these annotations, you can enhance the clarity, maintainability, and functionality of your Java SE 11 applications, ensuring that your code is well-documented and adheres to best practices.