В този урок ще научим за различни видове анотации на Java с помощта на примери.
Java анотациите са метаданни (данни за данни) за изходния код на нашата програма. Има няколко предварително дефинирани анотации, предоставени от Java SE. Освен това можем да създаваме и персонализирани пояснения според нашите нужди.
Ако не знаете какво представляват анотациите, посетете урока за анотации на Java.
Тези пояснения могат да бъдат категоризирани като:
1. Предварително дефинирани анотации
@Deprecated
@Override
@SuppressWarnings
@SafeVarargs
@FunctionalInterface
2. Персонализирани анотации
3. Мета-анотации
@Retention
@Documented
@Target
@Inherited
@Repeatable
Предварително определени типове анотации
1. @ Поощрено
В @Deprecated
анотацията е маркер анотация, която показва елемент (клас, метод областта, и т.н.) е отхвърлена и е заменена с нова елемент.
Синтаксисът му е:
@Deprecated accessModifier returnType deprecatedMethodName() (… )
Когато дадена програма използва елемента, който е обявен за остарял, компилаторът генерира предупреждение.
Използваме Javadoc @deprecated
таг за документиране на оттегления елемент.
/** * @deprecated * why it was deprecated */ @Deprecated accessModifier returnType deprecatedMethodName() (… )
Пример 1: Пример за неизвестна анотация
class Main ( /** * @deprecated * This method is deprecated and has been replaced by newMethod() */ @Deprecated public static void deprecatedMethod() ( System.out.println("Deprecated method"); ) public static void main(String args()) ( deprecatedMethod(); ) )
Изход
Остарял метод
2. @ Override
На @Override
уточнява, че анотация метод за подклас отменя метода на суперкласа със същото име метод, връщащ тип, и списъка параметър.
Не е задължително да се използва, @Override
когато се замени метод. Ако обаче го използваме, компилаторът дава грешка, ако нещо не е наред (например грешен тип параметър), докато замества метода.
Пример 2: Пример за анотация на @Override
class Animal ( // overridden method public void display()( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // overriding method @Override public void display()( System.out.println("I am a dog"); ) public void printMessage()( display(); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printMessage(); ) )
Изход
Аз съм куче
В този пример, като направим обект dog1 от клас Dog, можем да извикаме неговия метод printMessage (), който след това изпълнява display()
оператора.
Тъй като display()
е дефиниран и в двата класа, методът на подклас Dog отменя метода на суперклас Animal. Следователно, display()
се нарича подкласът.
3. @SuppressWarnings
Както подсказва името, @SuppressWarnings
анотацията инструктира компилатора да потисне предупрежденията, които се генерират, докато програмата се изпълнява.
Можем да посочим вида на предупрежденията, които да бъдат потиснати. Предупрежденията, които могат да бъдат потиснати, са специфични за компилатора, но има две категории предупреждения: оттегляне и непроверено .
За да потиснем определена категория предупреждение, използваме:
@SuppressWarnings("warningCategory")
Например,
@SuppressWarnings("deprecated")
За да потиснем множество категории предупреждения, използваме:
@SuppressWarnings(("warningCategory1", "warningCategory2"))
Например,
@SuppressWarnings(("deprecated", "unchecked"))
Категория deprecated
инструктира компилатора да потиска предупрежденията, когато използваме оттеглени елементи.
Категория unchecked
инструктира компилатора да потиска предупрежденията, когато използваме сурови типове.
И недефинираните предупреждения се игнорират. Например,
@SuppressWarnings("someundefinedwarning")
Пример 3: Пример за анотация @SuppressWarnings
class Main ( @Deprecated public static void deprecatedMethod() ( System.out.println("Deprecated method"); ) @SuppressWarnings("deprecated") public static void main(String args()) ( Main depObj = new Main(); depObj. deprecatedMethod(); ) )
Изход
Остарял метод
Тук deprecatedMethod()
е означен като оттеглен и ще дава предупреждения на компилатора, когато се използва. Използвайки @SuppressWarnings("deprecated")
анотацията, можем да избегнем предупрежденията на компилатора.
4. @SafeVarargs
The @SafeVarargs
annotation asserts that the annotated method or constructor does not perform unsafe operations on its varargs (variable number of arguments).
We can only use this annotation on methods or constructors that cannot be overridden. This is because the methods that override them might perform unsafe operations.
Before Java 9, we could use this annotation only on final or static methods because they cannot be overridden. We can now use this annotation for private methods as well.
Example 4: @SafeVarargs annotation example
import java.util.*; class Main ( private void displayList(List… lists) ( for (List list : lists) ( System.out.println(list); ) ) public static void main(String args()) ( Main obj = new Main(); List universityList = Arrays.asList("Tribhuvan University", "Kathmandu University"); obj.displayList(universityList); List programmingLanguages = Arrays.asList("Java", "C"); obj.displayList(universityList, programmingLanguages); ) )
Warnings
Type safety: Potential heap pollution via varargs parameter lists Type safety: A generic array of List is created for a varargs parameter
Output
Note: Main.java uses unchecked or unsafe operations. (Tribhuvan University, Kathmandu University) (Tribhuvan University, Kathmandu University) (Java, C)
Here, List
… lists
specifies a variable-length argument of type List
. This means that the method displayList()
can have zero or more arguments.
The above program compiles without errors but gives warnings when @SafeVarargs
annotation isn't used.
When we use @SafeVarargs
annotation in the above example,
@SafeVarargs private void displayList(List… lists) (… )
We get the same output but without any warnings. Unchecked warnings are also suppressed when we use this annotation.
5. @FunctionalInterface
Java 8 first introduced this @FunctionalInterface
annotation. This annotation indicates that the type declaration on which it is used is a functional interface. A functional interface can have only one abstract method.
Example 5: @FunctionalInterface annotation example
@FunctionalInterface public interface MyFuncInterface( public void firstMethod(); // this is an abstract method )
If we add another abstract method, let's say
@FunctionalInterface public interface MyFuncInterface( public void firstMethod(); // this is an abstract method public void secondMethod(); // this throws compile error )
Now, when we run the program, we will get the following warning:
Unexpected @FunctionalInterface annotation @FunctionalInterface MyFuncInterface is not a functional interface multiple non-overriding abstract methods found in interface MyFuncInterface
It is not mandatory to use @FunctionalInterface
annotation. The compiler will consider any interface that meets the functional interface definition as a functional interface.
We use this annotation to make sure that the functional interface has only one abstract method.
However, it can have any number of default and static methods because they have an implementation.
@FunctionalInterface public interface MyFuncInterface( public void firstMethod(); // this is an abstract method default void secondMethod() (… ) default void thirdMethod() (… ) )
Custom Annotations
It is also possible to create our own custom annotations.
Its syntax is:
(Access Specifier) @interface ( DataType () (default value); )
Here is what you need to know about custom annotation:
- Annotations can be created by using
@interface
followed by the annotation name. - The annotation can have elements that look like methods but they do not have an implementation.
- The default value is optional. The parameters cannot have a null value.
- The return type of the method can be primitive, enum, string, class name or array of these types.
Example 6: Custom annotation example
@interface MyCustomAnnotation ( String value() default "default value"; ) class Main ( @MyCustomAnnotation(value = "programiz") public void method1() ( System.out.println("Test method 1"); ) public static void main(String() args) throws Exception ( Main obj = new Main(); obj.method1(); ) )
Output
Test method 1
Meta Annotations
Meta-annotations are annotations that are applied to other annotations.
1. @Retention
The @Retention
annotation specifies the level up to which the annotation will be available.
Its syntax is:
@Retention(RetentionPolicy)
There are 3 types of retention policies:
- RetentionPolicy.SOURCE - The annotation is available only at the source level and is ignored by the compiler.
- RetentionPolicy.CLASS - The annotation is available to the compiler at compile-time, but is ignored by the Java Virtual Machine (JVM).
- RetentionPolicy.RUNTIME - The annotation is available to the JVM.
For example,
@Retention(RetentionPolicy.RUNTIME) public @interface MyCustomAnnotation(… )
2. @Documented
By default, custom annotations are not included in the official Java documentation. To include our annotation in the Javadoc documentation, we use the @Documented
annotation.
For example,
@Documented public @interface MyCustomAnnotation(… )
3. @Target
We can restrict an annotation to be applied to specific targets using the @Target
annotation.
Its syntax is:
@Target(ElementType)
The ElementType
can have one of the following types:
Element Type | Target |
---|---|
ElementType.ANNOTATION_TYPE | Annotation type |
ElementType.CONSTRUCTOR | Constructors |
ElementType.FIELD | Fields |
ElementType.LOCAL_VARIABLE | Local variables |
ElementType.METHOD | Methods |
ElementType.PACKAGE | Package |
ElementType.PARAMETER | Parameter |
ElementType.TYPE | Any element of class |
For example,
@Target(ElementType.METHOD) public @interface MyCustomAnnotation(… )
In this example, we have restricted the use of this annotation to methods only.
Note: If the target type is not defined, the annotation can be used for any element.
4. @Inherited
By default, an annotation type cannot be inherited from a superclass. However, if we need to inherit an annotation from a superclass to a subclass, we use the @Inherited
annotation.
Its syntax is:
@Inherited
For example,
@Inherited public @interface MyCustomAnnotation (… ) @MyCustomAnnotation public class ParentClass(… ) public class ChildClass extends ParentClass (… )
5. @Repeatable
An annotation that has been marked by @Repeatable
can be applied multiple times to the same declaration.
@Repeatable(Universities.class) public @interface University ( String name(); )
Стойността, дефинирана в @Repeatable
анотацията, е анотацията на контейнера. Анотацията на контейнера има променлива стойност на типа масив на горната повторяема анотация. Тук Universities
са съдържащите тип анотация.
public @interface Universities ( University() value(); )
Сега @University
анотацията може да се използва няколко пъти в една и съща декларация.
@University(name = "TU") @University(name = "KU") private String uniName;
Ако трябва да извлечем данните за поясненията, можем да използваме API за отразяване.
За да извлечем стойности на анотациите, използваме getAnnotationsByType()
или getAnnotations()
метод, дефиниран в API за отразяване.