TechCodeview

Java Anotación es una etiqueta que representa el metadatos es decir, adjunto con clase, interfaz, métodos o campos para indicar información adicional que puede ser utilizada por el compilador de Java y la JVM.

Las anotaciones en Java se utilizan para proporcionar información adicional, por lo que es una opción alternativa para las interfaces de marcadores XML y Java.

Primero, aprenderemos algunas anotaciones integradas y luego continuaremos creando y usando anotaciones personalizadas.

Anotaciones Java integradas

Hay varias anotaciones integradas en Java. Algunas anotaciones se aplican al código Java y otras a otras anotaciones.

Anotaciones Java integradas utilizadas en el código Java

• @Anular
• @SuppressWarnings
• @Obsoleto

Anotaciones Java integradas utilizadas en otras anotaciones

• @Objetivo
• @Retención
• @Heredado
• @Documentado

Comprender las anotaciones integradas

Primero comprendamos las anotaciones integradas.

@Anular

La anotación @Override asegura que el método de la subclase anula el método de la clase principal. Si no es así, se produce un error en tiempo de compilación.

A veces, cometemos errores tontos, como errores ortográficos, etc. Por lo tanto, es mejor marcar la anotación @Override que proporciona seguridad de que el método se anula.

madhubala

 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ón @SuppressWarnings: se utiliza para suprimir las advertencias emitidas por el 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 elimina la anotación @SuppressWarnings('unchecked'), mostrará una advertencia en el momento de la compilación porque estamos usando una colección no genérica.

@Obsoleto

La anotación @Deprecated marca que este método está en desuso, por lo que el compilador imprime una advertencia. Informa al usuario que puede eliminarse en versiones futuras. Por lo tanto, es mejor no utilizar estos métodos.

pruebas y tipos de software

 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 tiempo de compilación:

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

En tiempo de ejecución:

 hello n 

Anotaciones personalizadas de Java

Anotaciones personalizadas de Java o Las anotaciones definidas por el usuario de Java son fáciles de crear y usar. El @interfaz El elemento se utiliza para declarar una anotación. Por ejemplo:

 @interface MyAnnotation{} 

Aquí, MyAnnotation es el nombre de la anotación personalizada.

Puntos para recordar para la firma de anotación personalizada de Java

Hay algunos puntos que el programador debe recordar.

1. El método no debe tener cláusulas throws
2. El método debe devolver uno de los siguientes: tipos de datos primitivos, cadena, clase, enumeración o matriz de estos tipos de datos.
3. El método no debe tener ningún parámetro.
4. Deberíamos adjuntar @ justo antes de la palabra clave de interfaz para definir la anotación.
5. Puede asignar un valor predeterminado al método.

Tipos de anotación

Hay tres tipos de anotaciones.

1. Anotación de marcador
2. Anotación de valor único
3. Anotación de valores múltiples

1) Anotación de marcador

Una anotación que no tiene método se llama anotación de marcador. Por ejemplo:

 @interface MyAnnotation{} 

@Override y @Deprecated son anotaciones de marcador.

2) Anotación de valor único

Una anotación que tiene un método se llama anotación de valor único. Por ejemplo:

 @interface MyAnnotation{ int value(); } 

También podemos proporcionar el valor predeterminado. Por ejemplo:

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

Cómo aplicar la anotación de valor único

Veamos el código para aplicar la anotación de valor único.

java convierte un número entero a una cadena

 @MyAnnotation(value=10) 

El valor puede ser cualquier cosa.

3) Anotación de valores múltiples

Una anotación que tiene más de un método se denomina anotación de valores múltiples. Por ejemplo:

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

También podemos proporcionar el valor predeterminado. Por ejemplo:

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

Cómo aplicar la anotación de valores múltiples

Veamos el código para aplicar la anotación de valores múltiples.

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

Anotaciones integradas utilizadas en anotaciones personalizadas en Java

• @Objetivo
• @Retención
• @Heredado
• @Documentado

@Objetivo

@Objetivo La etiqueta se utiliza para especificar en qué tipo se utiliza la anotación.

La anotación java.lang. Tipo de elemento enum declara muchas constantes para especificar el tipo de elemento donde se aplicará la anotación, como TIPO, MÉTODO, CAMPO, etc. Veamos las constantes de la enumeración ElementType:

ordenación por inserción en java

Ejemplo para especificar una anotación para una clase

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

Ejemplo para especificar anotaciones para una clase, métodos o campos

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

@Retención

@Retención La anotación se utiliza para especificar hasta qué nivel estará disponible la anotación.

Ejemplo para especificar la política de retención

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

Ejemplo de anotación personalizada: creación, aplicación y acceso a anotaciones

Veamos el ejemplo simple de crear, aplicar y acceder a anotaciones.

Archivo: Prueba.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 

¿Cómo se utilizan las anotaciones integradas en un escenario real?

En un escenario real, el programador de Java solo necesita aplicar anotaciones. Él/ella no necesita crear ni acceder a anotaciones. La creación y el acceso a las anotaciones son realizadas por el proveedor de implementación. En nombre de la anotación, el compilador de Java o JVM realiza algunas operaciones adicionales.

@Heredado

De forma predeterminada, las anotaciones no se heredan a las subclases. La anotación @Inherited marca la anotación que se heredará en las subclases.

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

@Documentado

@Documented Marca la anotación para su inclusión en la documentación.