Was ist eine Anmerkung:
Annotation (Annotation) ist eine von Java bereitgestellte Möglichkeit und Methode, beliebige Informationen und beliebige Metadaten (Metadaten) mit Elementen im Metaprogramm zu verknüpfen. Annotation (Annotation) ist eine Schnittstelle. Das Programm kann das Annotation-Objekt des angegebenen Programmelements durch Reflektion abrufen und dann die Metadaten in der Annotation über das Annotation-Objekt abrufen.
Annotation (Annotation) wird in JDK5.0 und späteren Versionen eingeführt. Es kann verwendet werden, um Dokumentation zu erstellen, Abhängigkeiten in Ihrem Code zu verfolgen und sogar grundlegende Überprüfungen zur Kompilierungszeit durchzuführen. In gewisser Weise werden Annotationen wie Modifikatoren verwendet und auf die Deklaration von Paketen, Typen, Konstruktoren, Methoden, Mitgliedsvariablen, Parametern und lokalen Variablen angewendet. Diese Informationen werden im Strukturpaar „name=value“ von Annotation gespeichert.
Die Mitglieder einer Annotation werden als Parameterlose Methoden im Annotation-Typ deklariert. Sein Methodenname und Rückgabewert definieren den Namen und Typ des Mitglieds. Hier gibt es eine bestimmte Standardsyntax: Es ist zulässig, den Standardwert eines beliebigen Annotation-Mitglieds zu deklarieren: Eine Annotation kann ein Name=Wert-Paar als Wert eines Annotation-Mitglieds verwenden, das natürlich keinen Standardwert definiert Das =value-Paar kann auch verwendet werden, um den Standardwert anderer Member-Werte zu überschreiben. Dies ähnelt in gewisser Weise den Vererbungsmerkmalen von Klassen. Der Konstruktor der übergeordneten Klasse kann als Standardkonstruktor der Unterklasse verwendet werden, er kann jedoch auch von der Unterklasse überschrieben werden.
Mithilfe von Annotationen können beliebige Informationen einem Programmelement (Klasse, Methode, Mitgliedsvariable usw.) zugeordnet werden. Es ist zu beachten, dass es hier eine Grundregel gibt: Anmerkungen können die Ausführung von Programmcode nicht beeinflussen. Unabhängig davon, ob Anmerkungen hinzugefügt oder gelöscht werden, wird der Code konsistent ausgeführt. Obwohl auf einige Anmerkungen zur Laufzeit über die Reflection-API-Methoden von Java zugegriffen wird, ignoriert der Java-Sprachinterpreter diese Anmerkungen während der Arbeit. Gerade weil die Java Virtual Machine Annotation ignoriert, kann der Annotationstyp im Code nur über einige unterstützende Tools abgerufen und verarbeitet werden. In diesem Artikel werden die standardmäßigen Annotations- und Meta-Annotationstypen behandelt. Das Tool, das diese Annotationstypen begleitet, ist der Java-Compiler (der sie natürlich auf besondere Weise verarbeitet).
-------------------------------------------------- ----------------------------------
Was sind Metadaten (Metadaten):
Metadaten werden mit dem Wort Metadaten übersetzt, was „Daten über Daten“ bedeutet.
Metadaten haben viele Funktionen. Beispielsweise haben Sie möglicherweise Javadoc-Kommentare verwendet, um automatisch Dokumentation zu generieren. Dies ist eine Art Metadatenfunktion. Im Allgemeinen können Metadaten verwendet werden, um Dokumentation zu erstellen, Codeabhängigkeiten zu verfolgen, Formatprüfungen zur Kompilierungszeit durchzuführen und vorhandene Konfigurationsdateien zu ersetzen. Wenn wir die Rolle von Metadaten klassifizieren wollen, gibt es derzeit keine klare Definition, wir können sie jedoch anhand ihrer Rolle grob in drei Kategorien einteilen:
1. Schreiben von Dokumenten: Generieren von Dokumenten anhand der im Code identifizierten Metadaten 2. Code-Analyse: Analysieren des Codes anhand der im Code identifizierten Metadaten 3. Kompilierungsprüfung: Mithilfe der im Code identifizierten Metadaten kann der Compiler eine grundlegende Kompilierung erreichen. Überprüfen Sie das Metadaten in Java liegen im Java-Code in Form von Tags vor. Das Vorhandensein von Metadaten-Tags hat keinen Einfluss auf die Kompilierung und Ausführung des Programmcodes. Sie werden nur zur Generierung anderer Dateien oder zur Kenntnis des zur Laufzeit ausgeführten Codes verwendet Information.
Zusammenfassend:
Erstens liegen Metadaten im Java-Code in Form von Tags vor.
Zweitens sind die durch Metadaten beschriebenen Informationen typsicher, das heißt, die Felder innerhalb der Metadaten haben eindeutige Typen.
Drittens erfordern Metadaten eine zusätzliche Verarbeitung durch andere Tools als den Compiler, der zum Generieren anderer Programmkomponenten verwendet wird.
Viertens können Metadaten nur auf der Ebene des Java-Quellcodes oder innerhalb der kompilierten Klassendatei vorhanden sein.
-------------------------------------------------- ----------------------------------
Anmerkung und Anmerkungstypen:
Anmerkung:
Annotation verwendet die neue Syntax von Java5.0 und ihr Verhalten ist Modifikatoren wie public und final sehr ähnlich. Jede Anmerkung hat einen Namen und die Anzahl der Mitglieder >=0. Jedes Mitglied einer Annotation hat einen Namen und einen Wert, der als Name=Wert-Paar bezeichnet wird (genau wie eine Javabean), und name=Wert lädt die Annotationsinformationen.
Anmerkungstyp:
Der Annotationstyp definiert den Namen, den Typ und den Mitgliedsstandardwert der Annotation. Man kann sagen, dass ein Annotation-Typ eine spezielle Java-Schnittstelle ist. Seine Mitgliedsvariablen sind eingeschränkt und bei der Deklaration eines Annotation-Typs ist eine neue Syntax erforderlich. Wenn wir über die Java-Reflection-API auf Annotation zugreifen, ist der Rückgabewert ein Objekt, das die Annotation-Typ-Schnittstelle implementiert. Durch den Zugriff auf dieses Objekt können wir problemlos auf seine Annotation-Mitglieder zugreifen. In den folgenden Kapiteln werden die drei Standard-Annotationstypen erwähnt, die im java.lang-Paket von java5.0 enthalten sind.
-------------------------------------------------- ----------------------------------
Anmerkungskategorien:
Entsprechend der Anzahl der Anmerkungsparameter können wir Anmerkungen in drei Kategorien einteilen:
1. Markierungsanmerkung: Ein Anmerkungstyp ohne Elementdefinition wird als Markierungsanmerkung bezeichnet. Dieser Anmerkungstyp nutzt lediglich seine eigene Anwesenheit oder Abwesenheit, um uns Informationen zu liefern. Beispielsweise ist die folgende Systemanmerkung @Override;
2. Einzelwertanmerkung 3. Vollständige Anmerkung
Je nach Verwendung und Zweck von Anmerkungen können wir Anmerkungen in drei Kategorien einteilen:
1. Integrierte JDK-Systemanmerkungen 2. Metaanmerkungen 3. Benutzerdefinierte Anmerkungen
-------------------------------------------------- ----------------------------------
Im System integrierte Standardanmerkungen:
Die Syntax von Annotationen ist relativ einfach. Mit Ausnahme der Verwendung des @-Symbols entspricht sie im Wesentlichen der in JavaSE integrierten Standardannotation, die in java.lang definiert ist.
@Override: Wird zum Ändern dieser Methode verwendet, um die Methode der übergeordneten Klasse zu überschreiben.
@Deprecated: wird zum Ändern veralteter Methoden verwendet;
@SuppressWarnings: Wird verwendet, um den Java-Compiler zu benachrichtigen, bestimmte Kompilierungswarnungen zu unterdrücken.
Schauen wir uns nacheinander die Funktionen und Verwendungsszenarien der drei integrierten Standardanmerkungen an.
-------------------------------------------------- ----------------------------------
@Override, überschreibende Methoden der übergeordneten Klasse einschränken:
@Override ist ein Markierungsanmerkungstyp, der zum Kommentieren von Methoden verwendet wird. Es zeigt, dass die mit Anmerkungen versehene Methode die Methode der übergeordneten Klasse überlädt und die Rolle der Behauptung spielt. Wenn wir diese Art von Annotation in einer Methode verwenden, die die Methode der übergeordneten Klasse nicht überschreibt, warnt Sie der Java-Compiler mit einem Kompilierungsfehler. Diese Anmerkung kommt oft ins Spiel, wenn wir versuchen, eine Methode einer übergeordneten Klasse zu überschreiben, aber den falschen Methodennamen schreiben. Die Verwendung ist äußerst einfach: Wenn Sie diese Annotation verwenden, fügen Sie einfach @Override vor der geänderten Methode hinzu. Der folgende Code ist ein Beispiel für die Verwendung von @Override zum Ändern der displayName()-Methode eines Versuchs, die übergeordnete Klasse zu überschreiben, es liegen jedoch Rechtschreibfehler vor:
public void displayName(){
System.out.println("Der Name der Frucht ist: *****");
}
}
Klasse Orange erweitert Frucht {
@Override
public void displayName(){
System.out.println("Der Name der Frucht ist: orange");
}
}
Klasse Apple erweitert Fruit {
@Override
public void displayname(){
System.out.println("Der Name der Frucht ist: Apple");
}
}
@Deprecated, das Tag ist veraltet:
Ebenso ist „Deprecated“ auch eine Markup-Anmerkung. Wenn ein Typ oder Typmitglied mit @Deprecated dekoriert ist, rät der Compiler von der Verwendung dieses annotierten Programmelements ab. Und diese Art der Änderung weist einen gewissen Grad an „Kontinuität“ auf: Wenn wir diesen veralteten Typ oder dieses veraltete Mitglied im Code durch Vererbung oder Überschreiben verwenden, obwohl der geerbte oder überschriebene Typ oder das geerbte oder überschriebene Mitglied nicht als @Deprecated deklariert ist, muss der Compiler immer noch warnen Du.
Es ist erwähnenswert, dass es einen Unterschied zwischen dem Annotationstyp @Deprecated und dem Tag @deprecated in Javadoc gibt: Ersteres wird vom Java-Compiler erkannt, während letzteres vom Javadoc-Tool erkannt und zum Generieren von Dokumentation (einschließlich Why-Programm) verwendet wird (Mitglieder sind veraltet und es wird beschrieben, wie sie verboten oder ersetzt werden sollten).
In Java 5.0 sucht der Java-Compiler immer noch nach den @deprecated Javadoc-Tags und verwendet sie, um Warnmeldungen zu generieren, wie es in früheren Versionen der Fall war. Diese Situation wird sich jedoch in nachfolgenden Versionen ändern, und wir sollten jetzt beginnen, @Deprecated anstelle des Javadoc-Tags @deprecated zu verwenden, um veraltete Methoden zu dekorieren.
Im folgenden Programm wird die Annotation @Deprecated verwendet, um die Methode als abgelaufen zu markieren. Gleichzeitig wird das Tag @deprecated in der Annotation der Methode verwendet, um die Methode als abgelaufen zu markieren.
/**
* @deprecated Diese Methode ist abgelaufen und wird nicht empfohlen.
*/
@Veraltet
public void showTaste(){
System.out.println("Der Geschmack fruchtiger Äpfel ist: knackig und süß");
}
public void showTaste(int typeId){
if(typeId==1){
System.out.println("Der Geschmack von Fruchtäpfeln ist: sauer");
}
sonst if(typeId==2){
System.out.println("Der Geschmack fruchtiger Äpfel ist: süß");
}
anders{
System.out.println("Der Geschmack fruchtiger Äpfel ist: knackig und süß");
}
}
}
öffentliche Klasse FruitRun {
/**
* @param args
*/
public static void main(String[] args) {
Apple apple=new Apple();
apple.displayName();
AppleService appleService=new AppleService();
appleService.showTaste();
appleService.showTaste(0);
appleService.showTaste(2);
}
}
-------------------------------------------------- ----------------------------------
SuppressWarnings, Compiler-Warnungen unterdrücken:
@SuppressWarnings wird verwendet, um Compiler-Warnungen für Klassen, Methoden, Mitgliedsvariablen und Variableninitialisierung selektiv zu deaktivieren. In Java5.0 stellt uns der von Sun bereitgestellte Javac-Compiler die Option -Xlint zur Verfügung, damit der Compiler vor legalem Programmcode warnen kann. Diese Warnung stellt in gewissem Maße einen Programmfehler dar. Wenn wir beispielsweise eine generische Sammlungsklasse verwenden, ohne ihren Typ anzugeben, gibt der Compiler eine Warnung „Ungeprüfte Warnung“ aus. Normalerweise müssen wir in diesem Fall den Code finden, der die Warnung verursacht hat. Wenn es sich wirklich um einen Fehler handelt, müssen wir ihn korrigieren. Wenn die Warnmeldung beispielsweise darauf hinweist, dass die Switch-Anweisung in unserem Code nicht alle möglichen Fälle abdeckt, sollten wir einen Standardfall hinzufügen, um diese Warnung zu vermeiden.
Manchmal können wir diese Warnung nicht vermeiden, wenn wir beispielsweise eine generische Sammlungsklasse verwenden, die mit nicht generischem alten Code interagieren muss. @SuppressWarning wird sich zu diesem Zeitpunkt als nützlich erweisen. Fügen Sie vor der aufgerufenen Methode die Änderung @SuppressWarnings hinzu, um den Compiler anzuweisen, die Warnung vor dieser Methode zu beenden.
SuppressWarning ist keine Markup-Anmerkung. Es verfügt über ein Mitglied vom Typ String[], der Wert dieses Mitglieds ist der Name der verbotenen Warnung. Für den Javac-Compiler gelten Warnnamen, die für die Option -Xlint gültig sind, auch für @SuppressWarings, und der Compiler ignoriert nicht erkannte Warnnamen.
Die Annotationssyntax ermöglicht es, dem Annotationsnamen Klammern zu folgen. In den Klammern werden durch Kommas getrennte Name=Wert-Paare verwendet, um den Mitgliedern der Annotation Werte zuzuweisen. Beispiele sind wie folgt:
@SuppressWarnings(value={ "rawtypes", "unchecked" })
öffentliche statische Liste<Fruit> getFruitList(){
List<Fruit> FruitList=new ArrayList();
return FruitList;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
öffentliche statische Liste<Fruit> getFruit(){
List<Fruit> FruitList=new ArrayList();
return FruitList;
}
@SuppressWarnings("unused")
public static void main(String[] args){
List<String> strList=new ArrayList<String>();
}
}
Eine kurze Beschreibung gängiger Parameterwerte, die von SuppressWarnings mit Anmerkungen versehen wurden:
1. Deprecation: Warnung, wenn veraltete Klassen oder Methoden verwendet werden;
2. ungeprüft: Warnung, wenn eine ungeprüfte Konvertierung durchgeführt wird, z. B. wenn eine Sammlung verwendet wird, werden keine Generika verwendet, um den Typ der gespeicherten Sammlung anzugeben;
3.Fallthrough: Warnung, wenn der Switch-Programmblock ohne Break direkt zur nächsten Situation führt;
4.Pfad: Warnung, wenn der Klassenpfad, der Quelldateipfad usw. nicht vorhandene Pfade enthalten;
5.serial: Warnung, wenn die serialVersionUID-Definition für eine serialisierbare Klasse fehlt;
6.finally: Warnung, wenn eine final-Klausel nicht normal ausgefüllt werden kann;
7.alle: Warnung vor allen oben genannten Situationen.