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.
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 :
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.
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.
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 :
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 :
Il existe cinq types de méta-annotations :
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 :
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)
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 :
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!