What do Java annotation ElementType constants mean?

java.lang.annotation.ElementType:

A program element type. The constants of this enumerated type provide a simple classification of the declared elements in a Java program. These constants are used with the Target meta-annotation type to specify where it is legal to use an annotation type.

There are the following constants:

• ANNOTATION_TYPE - Annotation type declaration
• CONSTRUCTOR - Constructor declaration
• FIELD - Field declaration (includes enum constants)
• LOCAL_VARIABLE - Local variable declaration
• METHOD - Method declaration
• PACKAGE - Package declaration
• PARAMETER - Parameter declaration
• TYPE - Class, interface (including annotation type), or enum declaration

Can someone explain what each of them are (where they'd be annotated in actual code)?

Let's say the annotation to which you specify the ElementType is called YourAnnotation:

• ANNOTATION_TYPE - Annotation type declaration. Note: This goes on other annotations

    @YourAnnotation
    public @interface AnotherAnnotation {..}
  

• CONSTRUCTOR - Constructor declaration

    public class SomeClass {
        @YourAnnotation
        public SomeClass() {..}
    }
  

• FIELD - Field declaration (includes enum constants)

    @YourAnnotation
    private String someField;
  

• LOCAL_VARIABLE - Local variable declaration. Note: This can't be read at runtime, so it is used only for compile-time things, like the @SuppressWarnings annotation.

    public void someMethod() {
        @YourAnnotation int a = 0;
    }
  

• METHOD - Method declaration

    @YourAnnotation
    public void someMethod() {..}
  

• PACKAGE - Package declaration. Note: This can be used only in package-info.java.

    @YourAnnotation
    package org.yourcompany.somepackage;
  

• PARAMETER - Parameter declaration

    public void someMethod(@YourAnnotation param) {..}
  

• TYPE - Class, interface (including annotation type), or enum declaration

    @YourAnnotation
    public class SomeClass {..}
  

You can specify multiple ElementTypes for a given annotation. E.g.:

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})

This summarizes the main ones:

@CustomTypeAnnotation
public class MyAnnotatedClass {
  @CustomFieldAnnotation
  private String foo;

  @CustomConstructorAnnotation
  public MyAnnotatedClass() {
  }

  @CustomMethodAnnotation
  public String bar(@CustomParameterAnnotation String str) {
    @CustomLocalVariableAnnotation String asdf = "asdf";
    return asdf + str;
  }
}

ANNOTATION_TYPE is an annotation on another annotation, like this:

@CustomAnnotationTypeAnnotation
public @interface SomeAnnotation {
  ..
}

Package is defined in a package-info.java file in the package, like this:

@CustomPackageLevelAnnotation
package com.some.package;

import com.some.package.annotation.PackageLevelAnnotation;

For more info on PACKAGE annotations see here and here.

TYPE:

Annotation:

@Target({ElementType.TYPE})    // This annotation can only be applied to
public @interface Tweezable {  // class, interface, or enum declarations.
}

and an example usage:

@Tweezable
public class Hair {
    ...
}

One good example of a practical application of TYPE and ANNOTATION_TYPE is a custom cross-field validation