This article is a review of Java Annotations.
Much of the material is coming from Java Documentation website.

Annoations uses

Information for
the compiler —
Annotations can be used by the compiler to detect errors or suppress
warnings.
Compile-time and
deployment-time processing — Software tools can process
annotation information to generate code, XML files, and so forth.
Runtime
processing —
Some annotations are available to be examined at runtime.

The Format of an Annotation

In its simplest form, an annotation looks like the
following:

@Entity

The at sign character (@) indicates to the compiler
that what follows is an annotation. In the following example, the annotation’s
name is Override:

@Override
void mySuperMethod() { ... }

The annotation can include elements, which can be named
or unnamed, and there are values for those elements:

@Author(
   name = "Benjamin Franklin",
   date = "3/27/2003"
)
class MyClass() { ... }

@SuppressWarnings(value = "unchecked")
void myMethod() { ... }

If there is just one element named value, then the name
can be omitted, as in:

@SuppressWarnings("unchecked")
void myMethod() { ... }

If the annotation has no elements, then the parentheses
can be omitted, as shown in the previous @Override example.

It is also possible to use multiple annotations on the
same declaration:

@Author(name = "Jane Doe")
@EBook
class MyClass { ... }

If the annotations have the same type, then this is
called a repeating annotation:

@Author(name = "Jane Doe")
@Author(name = "John Smith")
class MyClass { ... }

Declaring an Annotation Type

Many annotations replace comments in code.

Suppose that a software group traditionally starts the
body of every class with comments providing important information:

public class Generation3List extends Generation2List {

   // Author: John Doe
   // Date: 3/17/2002
   // Current revision: 6
   // Last modified: 4/12/2004
   // By: Jane Doe
   // Reviewers: Alice, Bill, Cindy

   // class code goes here

}

To add this same metadata with an annotation, you must
first define the annotation type. The syntax for doing this is:

@interface ClassPreamble {
   String author();
   String date();
   int currentRevision() default 1;
   String lastModified() default "N/A";
   String lastModifiedBy() default "N/A";
   // Note use of array
   String[] reviewers();
}

The annotation type definition looks similar to an
interface definition where the keyword interface is preceded by the at sign (@)
(@ = AT, as in annotation type). Annotation types are a form of interface, which
will be covered in a later lesson. For the moment, you do not need to understand
interfaces.

The body of the previous annotation definition contains
annotation type element declarations, which look a lot like methods. Note that
they can define optional default values.

After the annotation type is defined, you can use
annotations of that type, with the values filled in, like this:

@ClassPreamble (
   author = "John Doe",
   date = "3/17/2002",
   currentRevision = 6,
   lastModified = "4/12/2004",
   lastModifiedBy = "Jane Doe",
   // Note array notation
   reviewers = {"Alice", "Bob", "Cindy"}
)
public class Generation3List extends Generation2List {

// class code goes here

}

Note: To make the information in @ClassPreamble appear
in Javadoc-generated documentation, you must annotate the @ClassPreamble
definition with the @Documented annotation:

// import this to use @Documented
import java.lang.annotation.*;

@Documented
@interface ClassPreamble {

   // Annotation element definitions

}

Annotation usage example in real life

Retorfit2 Usage

public interface FreightService {
    @GET("supplierFreight/show")
    Observable<HttpResult<List<SupplierFreight>>> getFrrightList();
}

As you can see above, @GET is
annotation identifier.

Android Activity Usage

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding.setHandlers(this);
}

Dagger 2 Usage

@Module
public class AppModule {

    Application mApplication;

    public AppModule(Application application) {
        mApplication = application;
    }

    @Provides
    @Singleton
    Application providesApplication() {
        return mApplication;
    }
}

@Module let
Dagger2 link the module with an injector while compiling and @Singleton define the mApplication as
singleton.

There is really existed a lot of usages with Java
Annotations. As in Android, I would like to check it in official website to see what it provided to
us.