In diesem Tutorial lernen wir anhand von Beispielen, was Annotationen sind, verschiedene Java-Annotationen und wie man sie verwendet.
Java-Annotationen sind Metadaten (Daten zu Daten) für unseren Programmquellcode.
Sie stellen dem Compiler zusätzliche Informationen über das Programm zur Verfügung, sind jedoch nicht Teil des Programms selbst. Diese Anmerkungen wirken sich nicht auf die Ausführung des kompilierten Programms aus.
Anmerkungen beginnen mit @. Die Syntax lautet:
@AnnotationName
Nehmen wir ein Beispiel für eine @OverrideAnmerkung.
Die @OverrideAnnotation gibt an, dass die mit dieser Annotation markierte Methode die Methode der Oberklasse mit demselben Methodennamen, Rückgabetyp und derselben Parameterliste überschreibt.
Die Verwendung @Overridebeim Überschreiben einer Methode ist nicht obligatorisch . Wenn wir es jedoch verwenden, gibt der Compiler einen Fehler aus, wenn etwas falsch ist (z. B. ein falscher Parametertyp), während die Methode überschrieben wird.
Beispiel 1: @ Override Annotation-Beispiel
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(); ) )
Ausgabe
Ich bin ein Hund.
In diesem Beispiel ist das Verfahren displayInfo()sowohl in der Oberklasse Tier als auch in der Unterklasse Hund vorhanden. Wenn diese Methode aufgerufen wird, wird die Methode der Unterklasse anstelle der Methode in der Oberklasse aufgerufen.
Anmerkungsformate
Anmerkungen können auch Elemente (Elemente / Attribute / Parameter) enthalten.
1. Markierungsanmerkungen
Markierungsanmerkungen enthalten keine Elemente / Elemente. Es wird nur zum Markieren einer Erklärung verwendet.
Die Syntax lautet:
@AnnotationName ()
Da diese Anmerkungen keine Elemente enthalten, können Klammern ausgeschlossen werden. Beispielsweise,
@Override
2. Einzelelementanmerkungen
Eine Annotation mit einem einzelnen Element enthält nur ein Element.
Die Syntax lautet:
@AnnotationName (elementName = "elementValue")
Wenn es nur ein Element gibt, ist es eine Konvention, dieses Element als Wert zu benennen.
@AnnotationName (value = "elementValue")
In diesem Fall kann auch der Elementname ausgeschlossen werden. Der Elementname ist standardmäßig ein Wert.
@AnnotationName ("elementValue")
3. Anmerkungen zu mehreren Elementen
Diese Anmerkungen enthalten mehrere durch Kommas getrennte Elemente.
Die Syntax lautet:
@AnnotationName (Element1 = "Wert1", Element2 = "Wert2")
Platzierung von Anmerkungen
Jede Erklärung kann mit einer Anmerkung versehen werden, indem sie über dieser Erklärung platziert wird. Ab Java 8 können Anmerkungen auch vor einem Typ platziert werden.
1. Über den Erklärungen
Wie oben erwähnt, können Java-Annotationen über Klassen-, Methoden-, Schnittstellen-, Feld- und anderen Programmelementdeklarationen platziert werden.
Beispiel 2: @SuppressWarnings Annotation-Beispiel
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(); ) )
Ausgabe
Wortliste => (programiz)
Wenn das obige Programm ohne Verwendung der @SuppressWarnings("unchecked")Anmerkung kompiliert wird, kompiliert der Compiler das Programm weiterhin, gibt jedoch Warnungen wie:
Main.java verwendet ungeprüfte oder unsichere Vorgänge. Wortliste => (programiz)
Wir bekommen die Warnung
Main.java verwendet ungeprüfte oder unsichere Vorgänge
wegen der folgenden Aussage.
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.
- Laufzeitanweisungen - Einige Anmerkungen können definiert werden, um dem Programm zur Laufzeit Anweisungen zu geben. Auf diese Anmerkungen wird mit Java Reflection zugegriffen.
