Introduction Annotations en Java
Des 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. En outre, les annotations aident à fournir des instructions à votre compilateur java à suivre lors de la compilation de ce code java.
Lorsque vous utilisez les annotations, nous utilisons le signe «@», puis le 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 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 d'extension.
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 # 1 - Remplacer
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();
)
)
Production
Exemple # 2 - obsolète
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();
)
)
Production
Méta annotations
Il existe cinq types de méta-annotations:
- Documenté - Il informe que le membre ou la variable ou la classe qui utilise cette annotation doit être documenté par Javadoc ou tout autre outil similaire disponible.
- Cible - Il est utilisé pour spécifier à quel type l'annotation est utilisée. Il est principalement utilisé avec vos annotations personnalisées.
- Hérité - Il marque l'annotation à hériter de la sous-classe.
- Rétention: indique la durée de conservation des annotations avec le type annoté. Il prend l'argument de politique de rétention dont les valeurs possibles sont: SOURCE, CLASS et RUNTIME.
- Répétable - Ceci informe que les types d'annotation dont la déclaration annote est répétable.
Exemple - Documentation et conservation
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");
)
)
Production
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 les suivantes:
1. Annotations de marqueurs - Ces types d'annotations sont utilisés comme déclaration pour informer le développeur de la fonction ou de 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 si la fonction est déconseillée., etc. @Override, @Deprecated sont considérés comme des annotations de marqueur.
Exemple: DemoAnnotation ()
2. Annotations à valeur unique - Ce type d'annotation prend de la valeur pour spécifier la valeur du membre pour lequel l'annotation est placée devant et, par conséquent, n'a pas besoin de spécifier le nom de ce membre.
Exemple: DemoAnnotation («custId123»)
3. Annotations complètes - Ce type d'annotation prend plusieurs valeurs, paires et membres.
Exemple: DemoAnnotation (category = ”Toys”, value = 1500)
Douane
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 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();
)
)
)
Production
Conclusion
Dans cet article, nous avons appris ce que sont les annotations java et leurs types avec des exemples, ainsi que des exemples d'annotations intégrées fournies par java et codé nos annotations personnalisées.
Nous avons appris que les annotations sont utiles pour normaliser le code et aident également à mieux comprendre le code et sa structure.
Articles recommandés
Ceci est un guide des annotations Java. Ici, nous discutons de la façon d'annoter Java intégré avec les exemples et les sorties donnés. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Variables en Java
- Modèles en Java
- Tri rapide en Java
- Meilleurs compilateurs Java
- instanceOf en Java avec exemple