Metadata Annotation

Annotations are a form of metadata providing information about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate. Unlike comments, which are just information for developers, annotations have a number of uses.

Annotations can be used by the compiler to detect errors or suppress warnings. you have seen this with the at override annotation which is generated for you by IntelliJ.
Software Tools can process annotation information to do something like generate code, XML files, during deployment time processing. You might be familiar with Spring annotations such as @Controller and @AutoWired.

Runtime Annotations

Some annotations are available to be examined at runtime, but they have no effect on the runtime code. I will be covering the following exam objectives in the next few modules.

Annotations

Describe the purpose open annotations and typical usage patterns.
Apply annotations to classes and methods.
Describe commonly used annotations in the JDK
Declare custom annotations

What are Metadata Annotations in Java?

In Java, metadata annotations are used to provide additional information about a program that is not part of the program itself. They are used to decorate other parts of the code, such as classes, methods, and fields, and can be accessed at runtime using reflection. Metadata annotations can be used for a variety of purposes, such as providing information for code generation, runtime processing, and error checking.
Java has several built-in annotations, such as @Override, @Deprecated, and @SuppressWarnings, and it is also possible to create custom annotations by defining a new annotation type.
Annotations are typically written before the element that they are decorating, like this:

@AnnotationName
element

Annotations can also have members, like this:

@AnnotationName(memberName = "memberValue")
element

And can also have multiple members

@AnnotationName(memberName1 = "memberValue1", memberName2 = "memberValue2")
element

Example of Metadata Annotation using Java 17

Java 17 includes several metadata annotations that can be used to provide additional information about code elements. Here's an example of using the @SuppressWarnings annotation in Java 17:

public class Example {
    
    @SuppressWarnings("unchecked")
    public void myMethod() {
        List myList = new ArrayList();
        myList.add("Hello");
        myList.add(123);
        String str = (String) myList.get(0); // OK
        Integer i = (Integer) myList.get(1); // Warning: Unchecked cast
    }
}

In this example, the @SuppressWarnings annotation is used to suppress a warning about an unchecked cast that occurs when an element is retrieved from the list. The "unchecked" parameter tells the compiler to ignore the warning and allow the cast to proceed.
The @SuppressWarnings annotation is a useful way to suppress warnings that may occur in code that is otherwise safe and correct, and is commonly used in cases where a warning is unavoidable due to the limitations of the type system. It's important to use this annotation judiciously, however, as suppressing warnings can mask potential problems and make it more difficult to maintain and debug code.