Java Anotació és una etiqueta que representa el metadades és a dir, s'adjunta amb classe, interfície, mètodes o camps per indicar informació addicional que pot utilitzar el compilador de Java i la JVM.

Les anotacions en Java s'utilitzen per proporcionar informació addicional, de manera que és una opció alternativa per a les interfícies de marcadors XML i Java.

Primer, aprendrem algunes anotacions integrades i després seguirem creant i utilitzant anotacions personalitzades.

Anotacions Java incorporades

Hi ha diverses anotacions integrades a Java. Algunes anotacions s'apliquen al codi Java i algunes a altres anotacions.

Anotacions Java incorporades utilitzades al codi Java

• @Anul·lació
• @SuppressWarnings
• @obsolet

Anotacions Java incorporades utilitzades en altres anotacions

• @Objectiu
• @Retenció
• @Heretat
• @Documentat

Comprensió de les anotacions integrades

Entenem primer les anotacions integrades.

@Anul·lació

L'anotació @Override assegura que el mètode de la subclasse està anul·lant el mètode de la classe pare. Si no és així, es produeix un error de temps de compilació.

De vegades, cometem errors ximples, com ara faltes d'ortografia, etc. Per tant, és millor marcar l'anotació @Override que garanteix que el mètode s'ha anul·lat.

eliminació d'un arbre de cerca binari

 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 

@SuppressWarnings

Anotació @SuppressWarnings: s'utilitza per suprimir els avisos emesos pel compilador.

 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 elimineu l'anotació @SuppressWarnings('sense marcar'), mostrarà un avís en temps de compilació perquè estem utilitzant una col·lecció no genèrica.

@obsolet

L'anotació @Deprecated indica que aquest mètode està obsolet, de manera que el compilador imprimeix un avís. Informa a l'usuari que pot ser eliminat en futures versions. Per tant, és millor no utilitzar aquests mètodes.

pandes loc

 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(); }} 

En temps de compilació:

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

En temps d'execució:

 hello n 

Anotacions personalitzades de Java

Anotacions personalitzades de Java o Java Les anotacions definides per l'usuari són fàcils de crear i utilitzar. El @interfície element s'utilitza per declarar una anotació. Per exemple:

 @interface MyAnnotation{} 

Aquí, MyAnnotation és el nom de l'anotació personalitzada.

Punts a recordar per a la signatura d'anotació personalitzada de Java

Hi ha pocs punts que el programador hauria de recordar.

1. El mètode no ha de tenir cap clàusula de llançament
2. El mètode hauria de retornar un dels següents: tipus de dades primitius, cadena, classe, enumeració o matriu d'aquests tipus de dades.
3. El mètode no ha de tenir cap paràmetre.
4. Hauríem d'adjuntar @ just abans de la paraula clau de la interfície per definir l'anotació.
5. Pot assignar un valor per defecte al mètode.

Tipus d'anotació

Hi ha tres tipus d'anotacions.

1. Anotació del marcador
2. Anotació d'un sol valor
3. Anotació multivalor

1) Anotació del marcador

Una anotació que no té cap mètode s'anomena anotació de marcador. Per exemple:

 @interface MyAnnotation{} 

@Override i @Deprecated són anotacions de marcador.

2) Anotació d'un sol valor

Una anotació que té un mètode, s'anomena anotació d'un sol valor. Per exemple:

 @interface MyAnnotation{ int value(); } 

També podem proporcionar el valor predeterminat. Per exemple:

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

Com aplicar l'anotació d'un sol valor

Vegem el codi per aplicar l'anotació de valor únic.

comparar amb la cadena

 @MyAnnotation(value=10) 

El valor pot ser qualsevol cosa.

3) Anotació multivalor

Una anotació que té més d'un mètode s'anomena anotació multivalor. Per exemple:

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

També podem proporcionar el valor predeterminat. Per exemple:

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

Com aplicar l'anotació multivalor

Vegem el codi per aplicar l'anotació multivalor.

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

Anotacions integrades utilitzades en anotacions personalitzades a Java

• @Objectiu
• @Retenció
• @Heretat
• @Documentat

@Objectiu

@Objectiu L'etiqueta s'utilitza per especificar en quin tipus s'utilitza l'anotació.

L'anotació java.lang. ElementType enum declara moltes constants per especificar el tipus d'element on s'ha d'aplicar l'anotació, com ara TYPE, METHOD, FIELD, etc. Vegem les constants d'ElementType enum:

cerca lineal en java

Exemple per especificar una anotació per a una classe

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

Exemple per especificar una anotació per a una classe, mètodes o camps

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

@Retenció

@Retenció L'anotació s'utilitza per especificar a quin nivell estarà disponible l'anotació.

Exemple per especificar la RetentionPolicy

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

Exemple d'anotació personalitzada: creació, aplicació i accés a l'anotació

Vegem un exemple senzill de creació, aplicació i accés a anotacions.

Fitxer: 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 

Com s'utilitzen les anotacions integrades en un escenari real?

En un escenari real, el programador java només necessita aplicar anotacions. Ell/ella no necessita crear anotacions ni accedir-hi. La creació i l'accés a l'anotació la realitza el proveïdor d'implementació. En nom de l'anotació, el compilador Java o JVM realitza algunes operacions addicionals.

@Heretat

Per defecte, les anotacions no s'hereten a les subclasses. L'anotació @Inherited marca l'anotació que s'heretarà a les subclasses.

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

@Documentat

@Documented Marca l'anotació per incloure-la a la documentació.