Annotations Java

Les annotations ont été introduites ou sont devenues disponibles dans la version 1.5 du Java Development Kit (JDK). Les annotations en Java fournissent plus d'informations sur les données présentes dans la structure du code, c'est-à-dire qu'il s'agit de données sur les données, également appelées métadonnées.

Que sont les annotations en Java ?

Les annotations aident à définir les métadonnées dans le code de manière standardisée. De plus, les annotations aident à fournir des instructions à votre compilateur Java à suivre lors de la compilation de ce code Java.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Lors de l'utilisation des annotations, nous utilisons le signe '@' puis suivi du nom de votre annotation afin que le compilateur la traite comme une annotation.

Il est important de noter que les annotations peuvent être ajoutées avant :

• Une déclaration de classe
• Une déclaration de variable membre
• Une déclaration de constructeur
• Une déclaration de méthode
• Une déclaration de paramètre
• Une déclaration de variable locale.

Les points importants à retenir sont que toutes les annotations étendent l'interface java.lang.annotation.Annotation. De plus, les annotations ne peuvent inclure aucune clause étendue.

Annotations Java intégrées

En Java, il existe des annotations intégrées telles que @Override, @Deprecated, @SuppressWarnings qui sont conçues dans un but spécifique et utilisées dans l'une des situations ci-dessus, par exemple, uniquement pour la classe ou uniquement pour la méthode, etc.

Exemple n°1 – Remplacer

Code :

class Dad {
public void say() {
System.out.println("Do your homework");
}
}
public class Child extends Dad {
@Override
public void say(){
System.out.println("I wanna play");
}
public static void main(String args[]){
Dad daddy = new Child();
daddy.say();
}
}

Sortie :

Exemple n°2 – Obsolète

Code :

public class Outdated
{
@Deprecated
public void oldShow()
{
System.out.println("This Method is deprecated");  }
public static void main(String args[])
{
Outdated  od = new Outdated ();
od.oldShow();
}
}

Sortie :

Méta-annotations

Il existe cinq types de méta-annotations :

1. Documenté – Il informe que le membre, la variable ou la classe qui utilise cette annotation doit être documenté par Javadoc ou tout autre outil similaire disponible.
2. Cible – Il est utilisé pour spécifier à quel type l'annotation est utilisée. Il est principalement utilisé avec vos annotations personnalisées.
3. Hérité – Il marque l'annotation à hériter de la sous-classe.
4. Rétention – Il indique la durée pendant laquelle les annotations avec le type annoté doivent être conservées. Il prend l'argument Retention Policy dont les valeurs possibles sont : SOURCE, CLASS et RUNTIME.
5. Répétable – Ceci informe que les types d'annotation dont il annote la déclaration sont répétables.

Exemple – Documentation et conservation

Code :

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@interface RSample {
String rentent();
}
@Documented
@interface DSample {
String doc();
}
public class MetaAnnotate {
public static void main(String arg[])
{
new MetaAnnotate().rentent();
new MetaAnnotate().doc();
}
@RSample (rentent="Meta Info R")
public void rentent() {
System.out.println("Retention Policy Applied");
}
@DSample(doc="Meta Info D")
public void doc() {
System.out.println("Code Documented with the value");
}
}

Sortie :

Explication :

• RetentionPolicy.RUNTIME – Cette valeur spécifie que la valeur d'annotation doit être disponible au moment de l'exécution pour inspection via la réflexion Java.
• Exécutez la commande Javadoc pour afficher la documentation de votre code.

Types d'annotations

Il existe trois catégories d'annotations, et elles sont les suivantes :

1. Annotations de marqueur – Ces types d'annotations sont utilisés comme déclaration pour informer le développeur de ce qu'est la fonction ou la classe ci-dessous, c'est-à-dire qu'elle partage des informations supplémentaires sur la fonction ou la classe, comme si la fonction remplace une autre fonction ou est la fonction obsolète, etc. @Override, @Deprecated sont considérés comme des annotations de marqueur.

Exemple : DemoAnnotation()

2. Annotations à valeur unique – Ce type d'annotation prend une valeur pour spécifier la valeur du membre pour lequel l'annotation est placée devant et n'a donc pas besoin de spécifier le nom de ce membre.

Exemple : DemoAnnotation("custId123")

3. Annotations complètes – Ce type d'annotation prend en compte plusieurs valeurs, paires, membres.

Exemple : DemoAnnotation(category=”Toys”, value=1500)

Personnalisé

Les annotations personnalisées sont créées par l'interface utilisateur, suivies d'un nom d'annotation, comme nous le verrons dans l'exemple ci-dessous.

Fichier 1 : annotation personnalisée définie

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Magicians
{
String Wizard() default "Reynolds";
String House() default "Green";
}
@Magicians
public class Magician
{
@Magicians(Wizard = "Harry Potter", House = "Red")
public String getString()  {  return null; }
}

Fichier 2 : Classe principale qui appelle la classe d'annotation personnalisée

import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
public class MyCustomAnnotation
{
public static void main(String[] args) throws NoSuchMethodException, SecurityException
{
new Magician();
Class<Magician> magic = Magician.class;
readAnnotationOn(magic);
Method method = magic.getMethod("getString", new Class[]{});
readAnnotationOn(method);
}
static void readAnnotationOn(AnnotatedElement element)
{
try
{
System.out.println("\n Find annotations on " + element.getClass().getName());
Annotation[] annotations = element.getAnnotations();
for (Annotation annotation : annotations)
{
if (annotation instanceof Magicians)
{
Magicians mData = (Magicians) annotation;
System.out.println("Wizard Name :" + mData.Wizard());
System.out.println("Wizard House Color :" + mData.House());
}
}
} catch (Exception e)
{
e.printStackTrace();
}
}
}

Sortie :

Conclusion

Dans cet article, nous avons vu ce que sont les annotations Java et leurs types avec des exemples, nous avons vu des exemples d'annotations intégrées fournies par Java et codé nos annotations personnalisées. Nous avons vu des annotations utiles pour standardiser le code et qui aident également à mieux comprendre le code et sa structure.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!