Les annotations sont une sorte de méta informations qui peuvent être associées aux types, variables, méthodes, ...
Les annotations n'affectent pas le comportement d'un code mais peuvent être utilisées pour des taches spécifiques: faire une vérification statique du code ou être lues à l'exécution pour faire des actions spécifiques.

Exemple :
public class AnnotationTest1 { @SuppressWarnings("unused") private void doSomeThing() { } }
Dans l'exemple précèdent, en absence de l'annotation SuppressWarnings, le compilateur affichera le message d'avertissement suivant : "The method doSomeThing() from the type AnnotationTest1 is never used locally".

Cette annotation (peut être appelée aussi méta annotation puisqu'elle s'applique sur des annotations) sert à préciser le type d'élément du programme sur lequel une annotation s'appliquera.

Cette annotation peut être appliquée sur les éléments suivants :

• ElementType.TYPE : déclaration de classe (incluant les enums) et d'interface (incluant les annotations)
  
• ElementType.FIELD : déclaration d'attribut (incluant les constantes enum)
  
• ElementType.METHOD : déclaration de méthode
  
• ElementType.PARAMETER : déclaration de paramètre
  
• ElementType.CONSTRUCTOR : déclaration de constructeur
  
• ElementType.LOCAL_VARIABLE : déclaration de variable locale
  
• ElementType.ANNOTATION_TYPE : déclaration du type annotation
  
• ElementType.PACKAGE : déclaration du package
  

Exemple :
package java.lang; import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface Override { }
Dans l'exemple précèdent, l'annotation Target informe le compilateur que l'annotation Override peut être utilisée uniquement avec la déclaration des méthodes.

Cette annotation précise la portée d'une annotation :

• RetentionPolicy.SOURCE : Ces annotations sont disponible uniquement dans le code source ; pratiquement utiles pour les compilateurs pour qu'ils fassent, par exemple, des vérifications lors de la compilation. Ces annotations disparaissent dans le bytecode de la classe.
  
• RetentionPolicy.CLASS : Ces annotations sont sauvegardées dans le bytecode de la classe.
  
• RetentionPolicy.RUNTIME : Ces annotations sont sauvegardées dans le bytecode de la classe et sont disponibles à l'exécution du code et donc peuvent être lues en utilisant la réélection.
  

Exemple :
package java.lang; import java.lang.annotation.*; import java.lang.annotation.ElementType; import static java.lang.annotation.ElementType.*; @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) @Retention(RetentionPolicy.SOURCE) public @interface SuppressWarnings { String[] value(); }
Dans l'exemple précèdent, l'annotation Retention informe le compilateur que l'annotation SuppressWarnings peut être utilisée uniquement dans le code source et ne doit pas être sauvegardée dans le bytecode de la classes.

La syntaxe pour créer une annotation ressemble à celle d'une interface ; on utilise le même mot clé interface mais précédé par la lettre "@".

Dans le corps de l'annotation on déclare les méthodes (éléments de l'annotation) dont les règles de déclaration sont les suivants :

• Les déclarations de méthode ne doivent pas avoir des paramètres ou renvoyées des exceptions.
  
• Les types de retour des méthodes sont limités aux types primitives, String, Class, enum, annotation, et tableaux des types précédents.
  
• Les méthodes peuvent avoir des valeurs par défaut.
  

Exemple :
import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface Annotation1 { double value() default 10.0; }
Si l'annotation contient un seul élément, alors il est préférable de donner le nom value à la méthode. De cet façon on peut ignorer le nom de l'élément lorsque l'annotation est utilisée dans le code, seule la valeur devrait être passée en argument.
Si l'annotation définit une valeur par défaut à cet élément alors les parenthèses peuvent aussi être ignorées lors de son utilisation dans le code.

Exemple :
public class Test1Annotation1 { @Annotation1 public Double myVar1; @Annotation1(1.2) public Double myVar2; @Annotation1(value=1.3) public Double myVar3; }
Une annotation peut n'avoir aucun élément et dans ce cas les parenthèses peuvent être ignorées lors de son utilisation dans le code.

Il est possible d'utiliser l'introspection pour manipuler les annotations à l'exécution du programme.

Exemple :
import java.lang.reflect.Field; public class Test2Annotation1 { @Annotation1 public Double myVar1; @Annotation1(1.2) public Double myVar2; @Annotation1(value=1.3) public Double myVar3; public static void main(String[] args) { for (Field f : Test2Annotation1.class.getFields()) { if (f.isAnnotationPresent(Annotation1.class)) { System.out.println(f.getAnnotation(Annotation1.class).value()); } } } }
Résultat d'exécution du code :
10.0 1.2 1.3