> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java Target Annotation
The `@Target` annotation is a meta-annotation in Java used to restrict the syntactic contexts where a custom annotation can be applied. By specifying one or more `ElementType` enum constants, it dictates the exact Java elements that are legally permitted to be decorated by the defined annotation, enforcing these restrictions at compile time.
## Syntax and Declaration
The `@Target` annotation accepts a single element named `value`, which is an array of `java.lang.annotation.ElementType`.
```java theme={"dark"}
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
// Single element target
@Target(ElementType.METHOD)
public @interface SingleTargetAnnotation {}
// Multiple element targets require array initializer syntax
@Target({ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface MultiTargetAnnotation {}
```
If the `@Target` meta-annotation is omitted from an annotation declaration, the resulting annotation can be applied to any declaration context (classes, methods, fields, etc.), but it cannot be applied to type parameter or type use contexts.
## The `ElementType` Enum
The scope of `@Target` is strictly defined by the constants within the `ElementType` enum. Each constant maps to a specific structural component of the Java programming language:
* `TYPE`: Class, interface (including annotation interfaces), enum, or record declaration.
* `FIELD`: Field declaration, including enum constants.
* `METHOD`: Method declaration.
* `PARAMETER`: Formal parameter declaration.
* `CONSTRUCTOR`: Constructor declaration.
* `LOCAL_VARIABLE`: Local variable declaration.
* `ANNOTATION_TYPE`: Annotation interface declaration (used to create other meta-annotations).
* `PACKAGE`: Package declaration (applied within `package-info.java`).
* `TYPE_PARAMETER`: Type variable declaration (introduced in Java 8).
* `TYPE_USE`: Any use of a type (introduced in Java 8).
* `MODULE`: Module declaration (introduced in Java 9, applied within `module-info.java`).
* `RECORD_COMPONENT`: Record component declaration (introduced in Java 14).
## Compilation Mechanics
The Java compiler reads the `@Target` annotation during the annotation processing phase. If a developer attempts to apply an annotation to a structural element not explicitly declared in the annotation's `@Target` array, the compiler throws an `annotation type not applicable to this kind of declaration` error.
Internally, `@Target` is defined as follows, demonstrating that it is restricted to annotating other annotations:
```java theme={"dark"}
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
ElementType[] value();
}
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
