Comprendre l'annotation en Java

J'ai essayé de passer par certains documents en ligne pour apprendre les annotations java.

Dans le code suivant, ce qui est arrivé à mon cher "Hello world" chaîne que j'ai passé dans cette ligne: @Test_Target(doTestTarget="Hello World !")?

@Target(ElementType.METHOD)
public @interface Test_Target {
   public String doTestTarget();
}

ci-dessus est l'annotation définie et c'est en dessous de son utilisation

public class TestAnnotations {
   @Test_Target(doTestTarget="Hello World !")
   private String str;
   public static void main(String arg[]) {
      new TestAnnotations().doTestTarget();
   }
   public void doTestTarget() {
      System.out.printf("Testing Target annotation");
   }
}

Lorsque j'exécute ce code, il est seulement l'impression Testing Target annotation

Merci de m'aider, je suis complètement nouveau pour l'annotation.

source d'informationauteur Anupam Gupta

annotations java

21

Annotations sont essentiellement des bits de données que vous pouvez attacher à des champs, méthodes, classes, etc.

La syntaxe pour déclarer les annotations en Java est un peu maladroit. Ils ressemblent un peu à des interfaces (ils sont, après tout, a déclaré avec @interface), mais ils ne sont pas vraiment des interfaces. Je pense que vous pourriez avoir mis le doTestTarget() méthode dans votre TestAnnotations classe parce que vous avez pensé de votre annotation est une interface et vous avez besoin de la mettre en œuvre. Ce n'est pas vrai, vous pouvez supprimer cette méthode et l'appel à partir de votre code si vous le souhaitez et cela ne sera pas vous causer des problèmes.

Aussi, vous pourriez ne pas avoir l'intention de mettre l'annotation sur le terrain str. Les Annotations s'appliquent uniquement à ce qui suit immédiatement. En conséquence, votre code ne compile pas, parce que vous avez appliqué votre annotation d'un domaine, mais a déclaré que l'annotation ne peut être appliqué qu'à des méthodes. Changement @Target(ElementType.METHOD) à @Target(ElementType.FIELD) et votre code doit ensuite compiler.

Comme pour ce qui se passe à la chaîne Hello World !il est écrit à la .fichier de classe et est disponible pour tout outil qui lit dans les classes Java. Cependant, il ne serait pas nécessairement disponibles dans la JVM au moment de l'exécution. Cela se produit parce que vous n'avez pas spécifié un @Retention pour votre @Test_Target annotation. La valeur par défaut pour @Retention est RetentionPolicy.CLASSce qui signifie que la JVM ne pourrait pas la peine de les charger de le fichier de classe. (Voir la Javadoc pour la RetentionPolicy enum.)

J'imagine que vous voulez voir une certaine manière de lire la valeur de cette annotation au moment de l'exécution. Si oui, je vous recommande l'ajout de @Retention(RetentionPolicy.RUNTIME) à votre annotation pour s'assurer qu'il sera disponible au moment de l'exécution.

Pour accéder à votre annotation et la valeur qu'elle contient, au moment de l'exécution, vous devez utiliser la réflexion. J'ai réécrit votre TestAnnotations classe comme suit pour donner une démonstration rapide:
```
import java.lang.reflect.Field;

public class TestAnnotations {

   @Test_Target(doTestTarget="Hello World !")
   private String str;

   public static void main(String[] args) throws Exception {
      //We need to use getDeclaredField here since the field is private.
      Field field = TestAnnotations.class.getDeclaredField("str");
      Test_Target ann = field.getAnnotation(Test_Target.class);
      if (ann != null) {
         System.out.println(ann.doTestTarget());
      }
   }
}
```
Lorsque j'exécute ce code, il me donne le résultat suivant:
```
Bonjour Tout Le Monde ! 
```
4

En principe, l'ajout d'une annotation par lui-même ne modifie pas fondamentalement les programmes de comportement.

Dans votre cas, vous avez créé un nouveau type d'annotation @Test_Targetqui peut être utilisé sur n'importe quelle méthode (comme l'indique son @Target annotation).

Puis d'appliquer ce pas une méthode, mais à la str champ (qui donne une erreur de compilation, je pense).

Indépendamment de cela, vous créez un objet avec un doTestTarget méthode, et à l'appeler, et obtenir le résultat escompté (c'est à dire l'exécution de la méthode).

Si vous voulez que votre annotation à faire quelque chose de plus que de simplement être là et de fournir des renseignements pour le lecteur de la source, vous devez l'utiliser, - soit avec un processeur d'annotation au moment de la compilation ou à l'aide de la réflexion sur le temps d'exécution (vous devez également @Retention(RUNTIME) comme une annotation sur Test_Target.)

Dans l'esprit de l'apprentissage, une autre méthode consiste à utiliser le annoté de la classe sans le ciblage d'une méthode ou un champ.
D'abord déclarer votre interface avec la méthode que vous avez besoin et de la Conservation de la Politique d'Exécution

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
public @interface Test_Target {
   public String doTestTarget() default "default string";
}

ensuite annoter l'interface créée pour votre classe. À partir de votre classe à trouver le annoté de la classe, puis d'appeler la méthode avec elle.

import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;

@Test_Target(doTestTarget="Hello World !")
public class TestAnnotations {

public static void main(String[] args) throws Exception 
{      
    AnnotatedElement c = TestAnnotations.class;
    if(c.isAnnotationPresent(Test_Target.class))
    {
        Annotation singleAnnotation = c.getAnnotation(Test_Target.class);
        Test_Target tt = (Test_Target) singleAnnotation;
        System.out.println(tt.doTestTarget());
    }       
}

}

le résultat est:
Bonjour Tout Le Monde !

Vous devez vous connecter pour publier un commentaire.