Java-annotaties

In deze tutorial leren we wat annotaties zijn, verschillende Java-annotaties en hoe je ze kunt gebruiken met behulp van voorbeelden.

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 nemen van @Override annotatie.

De @Override annotatie geeft aan dat de methode die met deze annotatie is gemarkeerd, de methode van de superklasse met dezelfde methodenaam, retourtype en parameterlijst overschrijft.

Het is niet verplicht om @Override . te gebruiken bij 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:Voorbeeld van @Override Annotatie

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

I am a dog.

In dit voorbeeld is de methode displayInfo() is aanwezig in zowel de superklasse Animal en subklasse Hond . 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. Markering annotaties

Markerannotaties 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 conventie om dat element te noemen als waarde .

@AnnotationName(value = "elementValue")

In dit geval kan ook de elementnaam worden uitgesloten. De naam van het element is waarde standaard.

@AnnotationName("elementValue")

3. Annotaties met meerdere elementen

Deze annotaties bevatten meerdere elementen gescheiden door komma's.

De syntaxis is:

@AnnotationName(element1 = "value1", element2 = "value2")

Annotatieplaatsing

Elke aangifte kan van een annotatie worden voorzien 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

Word list => [programiz]

Als het bovenstaande programma is gecompileerd zonder de @SuppressWarnings("unchecked") annotatie, zal de compiler het programma nog steeds compileren, maar het zal waarschuwingen geven zoals:

Main.java uses unchecked or unsafe operations.
Word list => [programiz]

We krijgen de waarschuwing

Main.java uses unchecked or unsafe operations

vanwege de volgende verklaring.

ArrayList wordList = new ArrayList<>();

Dit komt omdat we het generieke type van de arraylijst niet hebben gedefinieerd. We kunnen deze waarschuwing oplossen door generieke termen op te geven tussen punthaken <> .

ArrayList<String> wordList = new ArrayList<>();

2. Typ annotaties

Vóór Java 8 konden annotaties alleen worden toegepast op declaraties. Typeannotaties kunnen nu ook worden gebruikt. Dit betekent dat we annotaties kunnen plaatsen waar we een type gebruiken.

Aanroepingen van aannemers

new @Readonly ArrayList<>()

Typedefinities

@NonNull String str;

Deze declaratie specificeert niet-null variabele str van het type String om NullPointerException te vermijden .

@NonNull List<String> newList;

Deze verklaring specificeert een niet-null lijst van het type String .

List<@NonNull String> newList;

Deze declaratie specificeert een lijst met niet-null-waarden van het type String .

Type afgietsels

newStr = (@NonNull String) str;

verlengt en implementeert clausule

class Warning extends @Localized Message

werpt clausule

public String readMethod() throws @Localized IOException

Typeannotaties zorgen ervoor dat Java-code beter kan worden geanalyseerd en zorgt voor nog sterkere typecontroles.

Typen annotaties

1. Vooraf gedefinieerde annotaties

1. @Deprecated
2. @Override
3. @SuppressWarnings
4. @SafeVarargs
5. @FunctionalInterface

2. Meta-annotaties

1. @Retention
2. @Documented
3. @Target
4. @Inherited
5. @Repeatable

3. Aangepaste annotaties

Deze typen annotaties worden in detail beschreven in de zelfstudie Java-annotatietypen.

Gebruik van annotaties

• Instructies voor compileren - Annotaties kunnen worden gebruikt voor het geven van instructies aan de compiler, het detecteren van fouten of het onderdrukken van waarschuwingen. De ingebouwde annotaties @Deprecated , @Override , @SuppressWarnings worden voor deze doeleinden gebruikt.
• Instructies voor het compileren - Compileerinstructies die door deze annotaties worden geleverd, helpen de software bij het bouwen van tools om code, XML-bestanden en nog veel meer te genereren.
• Runtime-instructies - Sommige annotaties kunnen worden gedefinieerd om instructies te geven aan het programma tijdens runtime. Deze annotaties zijn toegankelijk via Java Reflection.