Java Annotation est une balise qui représente le métadonnées c'est-à-dire attaché à une classe, une interface, des méthodes ou des champs pour indiquer des informations supplémentaires qui peuvent être utilisées par le compilateur Java et la JVM.

Les annotations en Java sont utilisées pour fournir des informations supplémentaires, il s'agit donc d'une option alternative pour les interfaces de marqueurs XML et Java.

Tout d’abord, nous apprendrons quelques annotations intégrées, puis nous passerons à la création et à l’utilisation d’annotations personnalisées.

Annotations Java intégrées

Il existe plusieurs annotations intégrées en Java. Certaines annotations sont appliquées au code Java et d'autres à d'autres annotations.

Annotations Java intégrées utilisées dans le code Java

• @Passer outre
• @Supprimer les avertissements
• @Obsolète

Annotations Java intégrées utilisées dans d'autres annotations

• @Cible
• @Rétention
• @Hérité
• @Documenté

Comprendre les annotations intégrées

Comprenons d'abord les annotations intégrées.

@Passer outre

L'annotation @Override garantit que la méthode de la sous-classe remplace la méthode de la classe parent. Si ce n’est pas le cas, une erreur de compilation se produit.

Parfois, nous faisons des erreurs stupides telles que des fautes d'orthographe, etc. Il est donc préférable de marquer l'annotation @Override qui fournit l'assurance que la méthode est remplacée.

machine à états finis

 class Animal{ void eatSomething(){System.out.println('eating something');} } class Dog extends Animal{ @Override void eatsomething(){System.out.println('eating foods');}//should be eatSomething } class TestAnnotation1{ public static void main(String args[]){ Animal a=new Dog(); a.eatSomething(); }} 

 Output:Comple Time Error 

@Supprimer les avertissements

Annotation @SuppressWarnings : est utilisée pour supprimer les avertissements émis par le compilateur.

 import java.util.*; class TestAnnotation2{ @SuppressWarnings('unchecked') public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('sonoo'); list.add('vimal'); list.add('ratan'); for(Object obj:list) System.out.println(obj); }} 

 Now no warning at compile time. 

Si vous supprimez l'annotation @SuppressWarnings('unchecked'), elle affichera un avertissement au moment de la compilation car nous utilisons une collection non générique.

@Obsolète

L'annotation @Deprecated indique que cette méthode est obsolète, le compilateur affiche donc un avertissement. Il informe l'utilisateur qu'il pourra être supprimé dans les versions futures. Il est donc préférable de ne pas utiliser de telles méthodes.

ensemble de textes dactylographiés

 class A{ void m(){System.out.println('hello m');} @Deprecated void n(){System.out.println('hello n');} } class TestAnnotation3{ public static void main(String args[]){ A a=new A(); a.n(); }} 

Au moment de la compilation :

 Note: Test.java uses or overrides a deprecated API. <br> Note: Recompile with -Xlint:deprecation for details. 

Lors de l'exécution:

 hello n 

Annotations personnalisées Java

Annotations personnalisées Java ou Java Les annotations définies par l'utilisateur sont faciles à créer et à utiliser. Le @interface L'élément est utilisé pour déclarer une annotation. Par exemple:

 @interface MyAnnotation{} 

Ici, MyAnnotation est le nom de l'annotation personnalisée.

Points à retenir pour la signature d'annotation personnalisée Java

Il y a quelques points dont le programmeur doit se souvenir.

1. La méthode ne doit pas avoir de clauses throws
2. La méthode doit renvoyer l'un des éléments suivants : types de données primitifs, chaîne, classe, énumération ou tableau de ces types de données.
3. La méthode ne doit avoir aucun paramètre.
4. Nous devrions attacher @ juste avant le mot-clé d'interface pour définir l'annotation.
5. Il peut attribuer une valeur par défaut à la méthode.

Types d'annotations

Il existe trois types d'annotations.

1. Annotation des marqueurs
2. Annotation à valeur unique
3. Annotation multi-valeurs

1) Annotation des marqueurs

Une annotation qui n’a pas de méthode est appelée annotation de marqueur. Par exemple:

convertir un caractère en chaîne java

 @interface MyAnnotation{} 

@Override et @Deprecated sont des annotations de marqueur.

2) Annotation à valeur unique

Une annotation qui a une méthode est appelée annotation à valeur unique. Par exemple:

 @interface MyAnnotation{ int value(); } 

Nous pouvons également fournir la valeur par défaut. Par exemple:

 @interface MyAnnotation{ int value() default 0; } 

Comment appliquer l'annotation à valeur unique

Voyons le code pour appliquer l'annotation à valeur unique.

 @MyAnnotation(value=10) 

La valeur peut être n'importe quoi.

3) Annotation multi-valeurs

Une annotation qui comporte plusieurs méthodes est appelée annotation multi-valeurs. Par exemple:

 @interface MyAnnotation{ int value1(); String value2(); String value3(); } } 

Nous pouvons également fournir la valeur par défaut. Par exemple:

 @interface MyAnnotation{ int value1() default 1; String value2() default ''; String value3() default 'xyz'; } 

Comment appliquer l'annotation à valeurs multiples

Voyons le code pour appliquer l'annotation à valeurs multiples.

 @MyAnnotation(value1=10,value2='Arun Kumar',value3='Ghaziabad') 

Annotations intégrées utilisées dans les annotations personnalisées en Java

• @Cible
• @Rétention
• @Hérité
• @Documenté

@Cible

@Cible La balise est utilisée pour spécifier à quel type l'annotation est utilisée.

Le java.lang.annotation. Type d'élément enum déclare de nombreuses constantes pour spécifier le type d'élément où l'annotation doit être appliquée, comme TYPE, METHOD, FIELD etc. Voyons les constantes de l'énumération ElementType :

Exemple pour spécifier l'annotation d'une classe

 @Target(ElementType.TYPE) @interface MyAnnotation{ int value1(); String value2(); } 

Exemple pour spécifier une annotation pour une classe, des méthodes ou des champs

 @Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD}) @interface MyAnnotation{ int value1(); String value2(); } 

@Rétention

@Rétention l'annotation est utilisée pour spécifier à quel niveau l'annotation sera disponible.

scanner en java

Exemple pour spécifier la RetentionPolicy

 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface MyAnnotation{ int value1(); String value2(); } 

Exemple d'annotation personnalisée : création, application et accès à une annotation

Voyons l'exemple simple de création, d'application et d'accès à une annotation.

Fichier : Test.java

 //Creating annotation import java.lang.annotation.*; import java.lang.reflect.*; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface MyAnnotation{ int value(); } //Applying annotation class Hello{ @MyAnnotation(value=10) public void sayHello(){System.out.println('hello annotation');} } //Accessing annotation class TestCustomAnnotation1{ public static void main(String args[])throws Exception{ Hello h=new Hello(); Method m=h.getClass().getMethod('sayHello'); MyAnnotation manno=m.getAnnotation(MyAnnotation.class); System.out.println('value is: '+manno.value()); }} 

 Output:value is: 10 

Comment les annotations intégrées sont-elles utilisées dans un scénario réel ?

Dans un scénario réel, le programmeur Java n'a qu'à appliquer une annotation. Il n'a pas besoin de créer et d'accéder à des annotations. La création et l'accès aux annotations sont effectués par le fournisseur d'implémentation. Au nom de l'annotation, le compilateur Java ou JVM effectue certaines opérations supplémentaires.

@Hérité

Par défaut, les annotations ne sont pas héritées des sous-classes. L'annotation @Inherited marque l'annotation à hériter des sous-classes.

 @Inherited @interface ForEveryone { }//Now it will be available to subclass also @interface ForEveryone { } class Superclass{} class Subclass extends Superclass{} 

@Documenté

Le @Documented marque l'annotation à inclure dans la documentation.