In deze tutorial leren we aan de hand van voorbeelden wat annotaties zijn, verschillende Java-annotaties en hoe je ze kunt gebruiken.
Java-annotaties zijn metadata (data over data) voor onze programmabroncode.
Ze geven aanvullende informatie over het programma aan de compiler, maar maken geen deel uit van het programma zelf. Deze annotaties hebben geen invloed op de uitvoering van het gecompileerde programma.
Annotaties beginnen met @. De syntaxis is:
@AnnotationName
Laten we een voorbeeld van @Overrideannotatie nemen.
De @Overrideannotatie geeft aan dat de methode die met deze annotatie is gemarkeerd, de methode van de superklasse overschrijft met dezelfde methode naam, retourneringstype en parameterlijst.
Het is niet verplicht om te gebruiken @Overridebij het overschrijven van een methode. Als we het echter gebruiken, geeft de compiler een foutmelding als er iets mis is (zoals een verkeerd parametertype) terwijl de methode wordt overschreven.
Voorbeeld 1: @Override annotatievoorbeeld
class Animal ( public void displayInfo() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( @Override public void displayInfo() ( System.out.println("I am a dog."); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.displayInfo(); ) )
Uitvoer
Ik ben een hond.
In dit voorbeeld is de methode displayInfo()aanwezig in zowel de superklasse Animal als de subklasse Dog. Wanneer deze methode wordt aangeroepen, wordt de methode van de subklasse aangeroepen in plaats van de methode in de superklasse.
Annotatie-indelingen
Annotaties kunnen ook elementen bevatten (leden / attributen / parameters).
1. Markeringsaantekeningen
Markeringsannotaties bevatten geen leden / elementen. Het wordt alleen gebruikt voor het markeren van een aangifte.
De syntaxis is:
@AnnotationName ()
Aangezien deze annotaties geen elementen bevatten, kunnen haakjes worden uitgesloten. Bijvoorbeeld,
@Override
2. Annotaties met één element
Een annotatie met één element bevat slechts één element.
De syntaxis is:
@AnnotationName (elementName = "elementValue")
Als er maar één element is, is het een afspraak om dat element als waarde te noemen.
@AnnotationName (waarde = "elementValue")
In dit geval kan de elementnaam ook worden uitgesloten. De elementnaam is standaard waarde.
@AnnotationName ("elementValue")
3. Meerdere elementaantekeningen
Deze annotaties bevatten meerdere elementen, gescheiden door komma's.
De syntaxis is:
@AnnotationName (element1 = "waarde1", element2 = "waarde2")
Annotatieplaatsing
Elke aangifte kan worden gemarkeerd met annotatie door deze boven die aangifte te plaatsen. Vanaf Java 8 kunnen annotaties ook voor een type worden geplaatst.
1. Bovenstaande verklaringen
Zoals hierboven vermeld, kunnen Java-annotaties boven klasse-, methode-, interface-, veld- en andere programma-elementdeclaraties worden geplaatst.
Voorbeeld 2: @SuppressWarnings Annotatievoorbeeld
import java.util.*; class Main ( @SuppressWarnings("unchecked") static void wordsList() ( ArrayList wordList = new ArrayList(); // This causes an unchecked warning wordList.add("programiz"); System.out.println("Word list => " + wordList); ) public static void main(String args()) ( wordsList(); ) )
Uitvoer
Woordenlijst => (programiz)
Als het bovenstaande programma is gecompileerd zonder de @SuppressWarnings("unchecked")annotatie te gebruiken, zal de compiler het programma nog steeds compileren, maar het zal waarschuwingen geven zoals:
Main.java maakt gebruik van ongecontroleerde of onveilige bewerkingen. Woordenlijst => (programiz)
We krijgen de waarschuwing
Main.java maakt gebruik van ongecontroleerde of onveilige bewerkingen
vanwege de volgende verklaring.
ArrayList wordList = new ArrayList();
This is because we haven't defined the generic type of the array list. We can fix this warning by specifying generics inside angle brackets .
ArrayList wordList = new ArrayList();
2. Type annotations
Before Java 8, annotations could be applied to declarations only. Now, type annotations can be used as well. This means that we can place annotations wherever we use a type.
Constructor invocations
new @Readonly ArrayList()
Type definitions
@NonNull String str;
This declaration specifies non-null variable str of type String to avoid NullPointerException.
@NonNull List newList;
This declaration specifies a non-null list of type String.
List newList;
This declaration specifies a list of non-null values of type String.
Type casts
newStr = (@NonNull String) str;
extends and implements clause
class Warning extends @Localized Message
throws clause
public String readMethod() throws @Localized IOException
Type annotations enable Java code to be analyzed better and provide even stronger type checks.
Types of Annotations
1. Predefined annotations
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Meta-annotations
@Retention@Documented@Target@Inherited@Repeatable
3. Custom annotations
These annotation types are described in detail in the Java Annotation Types tutorial.
Use of Annotations
- Compiler instructions - Annotations can be used for giving instructions to the compiler, detect errors or suppress warnings. The built-in annotations
@Deprecated,@Override,@SuppressWarningsare used for these purposes. - Compile-time instructions - Compile-time instructions provided by these annotations help the software build tools to generate code, XML files and many more.
- Runtime-instructies - Sommige annotaties kunnen worden gedefinieerd om instructies aan het programma te geven tijdens runtime. Deze annotaties zijn toegankelijk via Java Reflection.
