Java @Hérité

Le @inherited en Java est une annotation utilisée pour marquer une annotation à hériter des sous-classes de la classe annotée. Le @inherited est une annotation intégrée, car nous savons que les annotations sont comme une balise qui représente des métadonnées qui donnent des informations supplémentaires au compilateur. De la même manière que l'annotation intégrée, qui existe dans le Javadoc, il est possible de créer une autre méta-annotation à partir d'une méta-annotation existante dans Java. Il existe en fait deux types d'annotations, un type d'annotations appliqué au code Java comme @override, et un autre type d'annotations appliqué à l'autre annotation comme @target @inherited. Donc @inherited est une annotation qui est appliquée à une autre annotation dont nous voulons créer des sous-classes ou dont nous voulons hériter pour qu'un autre utilisateur définisse une annotation.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

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

Syntaxe

La syntaxe du @inherited en java est –

@Inherited
public @interface MyAnnotation {// code of the MyAnnotation
}
@MyAnnotation
public class SuperClass {
// code of the SuperClass }
public class SubClass extends SuperClass { // code of the SubClass }

Comme dans la syntaxe ci-dessus, la classe SubClass est héritée de l'annotation @MyAnnotation, car elle est héritée de SuperClass, et SuperClass a une annotation @MyAnnotation.

Comment fonctionne @Inherited en Java ?

L'annotation @Inherited est utilisée ou annotée avec l'annotation (MyAnnotation comme dans la syntaxe ci-dessus), que l'@interface doit préfixer. Ensuite, cette annotation (MyAnnotation) peut être utilisée partout où cela est nécessaire pour l'appliquer en tant que @MyAnnotation. Ces annotations peuvent être appliquées juste avant la déclaration d'un élément et peuvent être appliquées à n'importe quel élément du programme comme les variables, la classe, les constructeurs, les méthodes, etc. Lorsque cette annotation définie par l'utilisateur est annotée sur la superclasse, elle est automatiquement héritée de sous-classes (sous-classe comme dans la syntaxe ci-dessus), comme nous pouvons le voir dans les exemples ci-dessous.

Exemples d'implémentation de l'annotation @Inherited en Java

Ensuite, nous écrivons le code Java pour comprendre plus clairement l'annotation @Inherited avec l'exemple suivant où nous utilisons l'annotation @Inherited pour hériter dans la sous-classe de la superclasse, comme ci-dessous –

Exemple n°1

Tout d'abord, nous créons une interface pour l'annotation @MyAnnotation, qui comporte deux champs, nom et code.

Code : //MyAnnotation.java

package demo;
import java.lang.annotation.Inherited;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Inherited
@Target ({ElementType.TYPE, ElementType.METHOD})
@Retention (RetentionPolicy.RUNTIME)
public @interface MyAnnotation
{
String name () default "unknown";
String code () default " ";
}

Ensuite, nous créons une superclasse pour utiliser l'annotation ci-dessus en annotant n'importe quelle classe, méthode ou variable et fournissons le nom de l'état et le code de l'état.

Code : //Super.java

package demo;
import demo.MyAnnotation;
@MyAnnotation (name = "Karnataka", code = "KA")
public class Super
{
public String getstateinfo ()
{
return null;
}
}

Ensuite, nous utilisons une annotation car il s'agit de métadonnées, ce qui signifie que nous devrions pouvoir obtenir ces métadonnées ou informations pour utiliser les informations d'annotation lorsque nous en avons besoin.

Code : //Demo.java

//as sub class
package demo;
import demo.MyAnnotation;
import demo.Super;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
public class Demo extends Super
{
public static void main ( String[] arg ) throws Exception
{
new Super ();
Class <Super>obj = Super.class;
getstateinfo (obj);
Method m = obj.getMethod ("getstateinfo", new Class[]{});
getstateinfo (m);
}
static void getstateinfo (AnnotatedElement e)
{
try
{
System.out.println ("Finding annotations on " + e.getClass ().getName ());
Annotation[] annotations = e.getAnnotations ();
for (Annotation a : annotations)
{
if (a instanceof MyAnnotation)
{
MyAnnotation stateInfo = (MyAnnotation) a;
System.out.println("Name of Annotation :" + stateInfo.annotationType ());
System.out.println("State Name :" + stateInfo.name ());
System.out.println("State code :" + stateInfo.code ());
System.out.println(new Demo ().getClass ().getAnnotation (MyAnnotation.class));
System.out.println(new Super ().getClass ().getAnnotation (MyAnnotation.class));
}
}
} catch (Exception ex)
{
System.out.println( ex );
}
}
}

Sortie : Lorsque nous exécutons la classe Demo.java, la sortie est.

Explication : Comme dans le code ci-dessus, l'annotation MyAnnotation est créée et également annotée par @Inherited. Dans la superclasse, l'annotation MyAnnotation était utilisée par l'instruction @MyAnnotation et annotée dans la classe. Et une autre classe Demo est créée, qui est la sous-classe de la Superclasse car elle est étendue à la Superclasse. Plus loin dans la méthode main() de la classe Demo, un objet de la Superclasse crée et accède à sa méthode qui est getstateinfo(), à travers cette méthode en itérant toutes ses annotations et en vérifiant si l'annotation est absente de MyAnnotation, si oui puis en imprimant des informations comme nous pouvons le voir ci-dessus. Mais une chose importante est que la classe Demo ou l'un de ses éléments n'est pas annoté dans MyAnnotation, mais montre toujours que MyAnnotation est annotée dans cette classe car elle est inhérente à la Superclass et la Superclass est héritée de MyAnnotation.

Ensuite, nous réécrivons le code Java ci-dessus pour comprendre plus clairement l'annotation @Inherited avec l'exemple suivant où nous n'utiliserons pas l'annotation @Inherited pour annoter MyAnnotation (comme annotation créée dans l'exemple ci-dessus) pour vérifier si cette annotation est héritée dans la sous-classe de sa superclasse ou non, comme ci-dessous –

Exemple n°2

Nous conserverons les classes Super.java et Demo.java comme ci-dessus, aucun changement dans ces classes, mais dans la classe MyAnnotation.java, nous faisons peu de changements, nous supprimons simplement l'annotation @Inherited pour annoter de MyAnnotation, comme on peut le voir ci-dessous –

Code : //MonAnnotation.java

package demo;
import java.lang.annotation.Inherited;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// no @Inherited
@Target ({ElementType.TYPE, ElementType.METHOD})
@Retention (RetentionPolicy.RUNTIME)
public @interface MyAnnotation
{
String name () default "unknown";
String code () default " ";
}

Sortie : Ensuite, lorsque nous exécutons la classe Demo.java, la sortie est.

Explication : Comme dans le résultat ci-dessus, nous pouvons voir qu'après le code d'état, la valeur « nulle » est imprimée, c'est-à-dire la valeur de retour de l'instruction « new  Demo ().getClass () .getAnnotation (MyAnnotation.class)", ce qui signifie que la classe de démonstration n'hérite (ou n'annote) aucune annotation MyAnnotation de sa superclasse, car l'annotation @Inherited n'est pas annotée dans MyAnnotation pour en hériter dans la sous-classe.

Conclusion

Le @inherited en java est une annotation intégrée appliquée à une autre annotation. Il est utilisé pour marquer une annotation à hériter des sous-classes de la classe annotée. Le @inherited est disponible dans le package java.lang.annotation.Inherited.

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!