Java-Anmerkungen
Java-Anmerkungen
In diesem Tutorial lernen wir anhand von Beispielen, was Annotationen sind, verschiedene Java-Annotationen und wie man sie verwendet.
Java-Annotationen sind Metadaten (Daten über Daten) für unseren Programmquellcode.
Sie liefern dem Compiler zusätzliche Informationen über das Programm, sind aber nicht Teil des Programms selbst. Diese Anmerkungen wirken sich nicht auf die Ausführung des kompilierten Programms aus.
Anmerkungen beginnen mit @ . Seine Syntax ist:
@AnnotationName
Nehmen wir ein Beispiel von @Override Anmerkung.
Die @Override annotation gibt an, dass die mit dieser Annotation gekennzeichnete Methode die Methode der Oberklasse mit demselben Methodennamen, Rückgabetyp und derselben Parameterliste überschreibt.
Die Verwendung von @Override ist nicht zwingend erforderlich beim Überschreiben einer Methode. Wenn wir es jedoch verwenden, gibt der Compiler einen Fehler aus, wenn etwas falsch ist (z. B. falscher Parametertyp), während er die Methode überschreibt.
Beispiel 1:Beispiel für eine @Override-Anmerkung
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
I am a dog.
In diesem Beispiel die Methode displayInfo() ist in beiden Oberklassen Animal vorhanden und Unterklasse Hund . Beim Aufruf dieser Methode wird statt der Methode der Oberklasse die Methode der Unterklasse aufgerufen.
Anmerkungsformate
Anmerkungen können auch Elemente (Mitglieder/Attribute/Parameter) enthalten.
1. Markierungsanmerkungen
Markierungsanmerkungen enthalten keine Mitglieder/Elemente. Es dient nur zur Kennzeichnung einer Deklaration.
Seine Syntax ist:
@AnnotationName()
Da diese Annotationen keine Elemente enthalten, können Klammern ausgeschlossen werden. Zum Beispiel
@Override
2. Anmerkungen zu einzelnen Elementen
Eine Einzelelement-Anmerkung enthält nur ein Element.
Seine Syntax ist:
@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 value standardmäßig.
@AnnotationName("elementValue")
3. Anmerkungen zu mehreren Elementen
Diese Anmerkungen enthalten mehrere durch Kommas getrennte Elemente.
Seine Syntax ist:
@AnnotationName(element1 = "value1", element2 = "value2")
Anmerkungsplatzierung
Jede Deklaration kann mit einer Anmerkung gekennzeichnet werden, indem sie über dieser Deklaration platziert wird. Ab Java 8 können Annotationen auch vor einen Typ gestellt werden.
1. Obige Erklärungen
Wie oben erwähnt, können Java-Anmerkungen über Klassen-, Methoden-, Schnittstellen-, Feld- und anderen Programmelement-Deklarationen platziert werden.
Beispiel 2:Beispiel für @SuppressWarnings-Anmerkung
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
Word list => [programiz]
Wenn das obige Programm ohne die Verwendung von @SuppressWarnings("unchecked") kompiliert wird Anmerkung, der Compiler kompiliert das Programm trotzdem, gibt aber Warnungen aus wie:
Main.java uses unchecked or unsafe operations. Word list => [programiz]
Wir erhalten die Warnung
Main.java uses unchecked or unsafe operations
wegen der folgenden Aussage.
ArrayList wordList = new ArrayList<>();
Dies liegt daran, dass wir den generischen Typ der Array-Liste nicht definiert haben. Wir können diese Warnung beheben, indem wir Generika in spitzen Klammern angeben <> .
ArrayList<String> wordList = new ArrayList<>();
2. Geben Sie Anmerkungen ein
Vor Java 8 konnten Annotationen nur auf Deklarationen angewendet werden. Jetzt können auch Typanmerkungen verwendet werden. Das bedeutet, dass wir Anmerkungen überall dort platzieren können, wo wir einen Typ verwenden.
Konstruktoraufrufe
new @Readonly ArrayList<>()
Typdefinitionen
@NonNull String str;
Diese Deklaration gibt die Nicht-Null-Variable str an vom Typ String um NullPointerException zu vermeiden .
@NonNull List<String> newList;
Diese Deklaration gibt eine Nicht-Null-Liste des Typs String an .
List<@NonNull String> newList;
Diese Deklaration gibt eine Liste von Nicht-Null-Werten des Typs String an .
Typumwandlungen
newStr = (@NonNull String) str;
erweitert und implementiert die Klausel
class Warning extends @Localized Message
throws-Klausel
public String readMethod() throws @Localized IOException
Typannotationen ermöglichen eine bessere Analyse von Java-Code und bieten noch stärkere Typprüfungen.
Arten von Anmerkungen
1. Vordefinierte Anmerkungen
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Meta-Anmerkungen
@Retention@Documented@Target@Inherited@Repeatable
3. Benutzerdefinierte Anmerkungen
Diese Annotationstypen werden ausführlich im Java Annotation Types Tutorial beschrieben.
Verwendung von Anmerkungen
- Compiler-Anleitung - Annotationen können verwendet werden, um Anweisungen an den Compiler zu geben, Fehler zu erkennen oder Warnungen zu unterdrücken. Die eingebauten Anmerkungen
@Deprecated,@Override,@SuppressWarningswerden für diese Zwecke verwendet. - Anweisungen zur Kompilierzeit - Von diesen Anmerkungen bereitgestellte Anweisungen zur Kompilierzeit helfen den Software-Build-Tools beim Generieren von Code, XML-Dateien und vielem mehr.
- Laufzeitanweisungen - Einige Anmerkungen können definiert werden, um dem Programm zur Laufzeit Anweisungen zu geben. Auf diese Anmerkungen wird mit Java Reflection zugegriffen.
Java