In Java wird in Java 5 Annotation eingeführt und wird verwendet, um die Meta -Informationen des Java -Code zu beschreiben. In der Regel beeinflussen Anmerkungen nicht direkt die Ausführung des Code, obwohl einige Anmerkungen verwendet werden können, um die Ausführung des Codes zu beeinflussen.
Was kann mit Anmerkungen getan werden
Anmerkungen in Java spielen normalerweise die folgenden Rollen
In
Annotation Grundlagen
Eine einfache Java -Annotation ähnelt @Entity. Wo @ bedeutet es, dem Compiler zu sagen, dass dies eine Annotation ist. Entität ist der Name der Annotation. Normalerweise in einer Datei lautet die Schreibmethode wie folgt
public @Interface Entity {
}
Annotationselemente
Java -Anmerkungen können Elemente verwenden, um einige Werte festzulegen, und die Elemente in den Anmerkungen ähneln den Attributen oder Parametern. Beispielcode zum Definieren von Anmerkungen mit Elementen
public @Interface Entity {
String tableName ();
}
Beispielcode mit Annotation, die Elemente enthält
@Entity (TableName = "Fahrzeuge")
Der Elementname der obigen Annotation lautet TableName und der Wertsatz sind Fahrzeuge. Anmerkungen ohne Elemente erfordern keine Klammern.
Wenn die Annotation mehrere Elemente enthält, lautet die Verwendungsmethode wie folgt
@Entity (tableName = "Fahrzeuge", primaryKey = "id")
Wenn die Annotation nur ein Element hat, schreiben wir sie normalerweise so
@InsertNew (value = "Ja")
In diesem Fall, wenn und nur wenn der Elementname Wert ist, können wir ihn auch abkürzen, das heißt, es besteht keine Notwendigkeit, den Elementnamenwert auszufüllen, der Effekt ist wie folgt
@InsertNew ("Ja")
Annotationsnutzung
Anmerkungen können verwendet werden, um diese Elemente im Code zu ändern
Ein vollständiges Beispiel für die Nutzung ist wie folgt
@EntityPublic Class Vehicle {@Persistent Protected String vehiclename = null; @Getter public String GetVehiclename () {return this.vehiclename; } public void setVehiclename (@Optional fasciclename) {this.vehiclename = vehiclename; } publiclist addVehiclenametolist (Listennamen) {@Optional List localnames = names; if (localnames == null) {localnames = new ArrayList (); } localnames.add (GetVehiclename ()); Lokalnamen zurückgeben; }}Eingebaute Java-Anmerkungen
Es gibt drei eingebaute Anmerkungen in Java, die zur Bereitstellung von Anweisungen für den Compiler verwendet werden. Sie sind
@Veraltet
Kann verwendet werden, um Klassen, Methoden und Eigenschaften zu markieren.
Wenn die obigen drei Elemente nicht mehr verwendet werden, verwenden Sie die @Deprecated Annotation. Wenn der Code die Klasse, Methode oder Eigenschaft der @Deprecated Annotation verwendet, warnt der Compiler Sie.
@Deprecated ist wie folgt sehr einfach zu bedienen: Annotation einer veralteten Klasse.
@DeprecatedPublic Class MyComponent {}Wenn wir die @Deprecated Annotation verwenden, wird empfohlen, das entsprechende @Deprecated Javadoc -Symbol in Verbindung damit zu verwenden und zu erklären, warum diese Klasse, Methode oder Eigenschaft veraltet ist und was die Alternative ist.
@Deprecated/** @Deprecated Diese Klasse ist voller Fehler. Verwenden Sie stattdessen MyNewComponent.*/Öffentliche Klasse MyComponent {}@Override
Die @Override -Annotation wird verwendet, um die Methode zur Umschreibung der übergeordneten Klasse zu ändern. Wenn eine Methode, die die übergeordnete Klasse nicht überschreibt, diese Annotation verwendet, fordert der Compiler einen Fehler auf.
Tatsächlich ist @Overide nicht erforderlich, um die Methoden der übergeordneten Klasse oder Schnittstelle in einer Unterklasse zu überschreiben. Es wird jedoch weiterhin empfohlen, diese Annotation zu verwenden. In einigen Fällen wird unter der Annahme, dass Sie den Namen der übergeordneten Klassenmethode ändern, die zuvor umgeschriebene Unterklasse -Methode nicht mehr umgeschrieben. Ohne @Overide werden Sie die Methode dieser Unterklasse nicht bemerken. Mit dieser Annotationsänderung fordert der Compiler Sie mit diesen Informationen auf.
Beispiele für die Verwendung von Override -Annotation
public class mySuperClass {public void dothing () {System.out.println ("Do the Thing"); }} public class mySubClass erweitert MySuperClass {@Override public void dothing () {System.out.println ("du it anders"); }}@Suppresswarnings
@SuppressWarnings wird verwendet, um den Compiler durch die Erzeugung von Warnmeldungen zu unterdrücken.
Die Elemente, die geändert werden können, sind Klassen, Methoden, Methodenparameter, Attribute und lokale Variablen
Verwendungsszenario: Wenn eine Methode eine veraltete Methode aufruft oder eine unsichere Konvertierung durchführt, erzeugt der Compiler eine Warnung. Wir können diese Methode hinzufügen
@SuppressWarnings Annotation zur Unterdrückung der Warnungen für die Compiler -Generation.
Hinweis: Verwenden Sie @SuppressWarnings Annotation und übernehmen Sie das Prinzip der Nähe. Wenn eine Methode beispielsweise eine Warnung hat, versuchen wir, @Suppresswarnings zu verwenden, um diese Methode zu kommentieren, anstatt die Klasse zu kommentieren, in der sich die Methode befindet. Obwohl beide den Compiler durch die Erzeugung von Warnungen unterdrücken können, desto kleiner ist der Umfang, desto besser, da der Umfang größer ist, was nicht förderlich ist, Warninformationen aus anderen Methoden unter dieser Klasse zu entdecken.
Beispiel für die Nutzung
@SuppresswarningsPublic void methodWithwarning () {}Erstellen Sie Ihre eigenen Anmerkungen
In Java können wir unsere eigenen Anmerkungen, Anmerkungen und Klassen erstellen, und die Schnittstellendateien werden in unserer eigenen Datei definiert. wie folgt
@Interface Myannotation {String value (); String name (); int age (); String [] newnames ();}Der obige Code definiert eine Annotation namens Myannotation, die 4 Elemente hat. Auch hier wird das Schlüsselwort @Interface verwendet, um dem Java -Compiler mitzuteilen, dass dies eine Annotation ist.
Wenn Sie genau hinschauen, werden Sie feststellen, dass die Definition von Annotationselementen der Schnittstellenmethode sehr ähnlich ist. Diese Elemente haben Typen und Namen. Diese Typen können sein
Im Folgenden sind die benutzerdefinierten Anmerkungen der App aufgeführt
@Myannotation (value = "123", name = "Jakob", Age = 37, newnames = {"Jenkov", "Peterson"}) Myclass {} öffentliche Klasse {}Beachten Sie, dass wir Werte für alle Annotationselemente festlegen müssen und niemand fehlen kann.
Annotation Element Standardwert
Für Elemente in Anmerkungen können wir Standardwerte für sie mit der Methode festlegen
@Interface Myannotation {String value () Standard ""; String name (); int age (); String [] newnames ();}Im obigen Code setzen wir den Standardwert des Wertelements auf eine leere Zeichenfolge. Wenn wir es verwenden, können wir den Wert nicht festlegen, dh den Wert den Standardwert der leeren Zeichenfolge verwenden. Verwenden Sie Beispielcode
@Myannotation (name = "Jakob", Age = 37, Newnames = {"Jenkov", "Peterson"}) öffentliche Klasse Myclass {}@Zurückbehaltung
@Retention ist eine Annotation, die zur Änderung der Annotation verwendet wird. Mit dieser Annotation können wir es tun.
Steuern Sie, ob Anmerkungen in die Klassendatei geschrieben werden, um zu steuern
Die Kontrolle ist einfach. Verwenden Sie einfach eine der folgenden drei Strategien.
RetentionPolicy.Source zeigt an, dass die Annotation nur im Quellcode vorhanden ist, keine Klassendateien vorhanden ist und während der Laufzeit nicht sichtbar sein kann. Häufige Anmerkungen sind @Override, @Suppresswarnings.
RetentionPolicy.Class Dies ist die Standard -Annotationspolitik. Unter dieser Strategie werden mit der .Class -Datei Anmerkungen vorhanden, können jedoch nicht zur Laufzeit zugegriffen werden. Normalerweise wird diese Annotationsstrategie verwendet, um auf einer Bytecode -Ebene zu arbeiten.
RetentionPolicy.Runtime kann nach dieser Richtlinie zur Laufzeit zugegriffen werden. Oft machen wir etwas in Kombination mit Reflexion.
Beispiel für die Verwendung von @Retention
Importieren Sie java.lang.annotation.retention; import Java.lang.annotation
@Ziel
Mit @Target Annotation können wir festlegen, welche Java -Elemente durch benutzerdefinierte Annotationen geändert werden können. Einfaches Beispiel
Importieren Sie java.lang.annotation.elementtype; importieren java.lang.annotation
Der obige Code zeigt, dass die Myannotation -Annotation die Methode nur ändern kann.
@Target kann die Parameterwerte wie folgt auswählen
@Inherited
Wenn Sie möchten, dass eine Klasse und ihre Unterklasse eine Annotation enthalten, können Sie @inherited verwenden, um diese Annotation zu ändern.
java.lang.annotation.inherited@inheritedpublic @Interface Myannotation {} 12@myannotationPublic Class MySuperClass {...} 1public Class MySubClass erweitert MySuperClass {...}Die allgemeine Bedeutung des obigen Code ist
1. Verwenden Sie @inherited, um die Annotation zu ändern
2. Annotation von MySuperClass mit Myannotation
3. Implementieren Sie eine Klasse Mysubclass erbt von MySuperClass
Durch die obigen Schritte hat MySubClass auch eine Myannotation -Annotation.
Dies sind einige grundlegende Konzepte zu den Anmerkungen in Java.
Das obige ist die Sortierung von Anmerkungen in Java. Wir werden in Zukunft weiterhin relevante Informationen hinzufügen. Vielen Dank für Ihre Unterstützung für diese Seite!