Klassen, Methoden, Variablen, Parameter, Pakete usw. in der Java-Sprache können alle annotiert werden. Anders als bei Javadoc kann der Inhalt von Java-Annotationen über Reflexion abgerufen werden. Wenn der Compiler Klassendateien erzeugt, können Annotationen in den Bytecode eingebettet werden. Die Java Virtual Machine kann Annotationsinhalte beibehalten, und der Inhalt kann zur Laufzeit abgerufen werden. Natürlich werden auch benutzerdefinierte Java-Annotationen unterstützt.
Es gibt viele Artikel über Java-Annotationen online, die verwirrend sein können. Java-Annotationen sind eigentlich recht einfach, aber die Autoren haben es versäumt, sie klar zu erklären, was die Leser noch mehr verwirrt.
Ich habe Annotationen nach meinem eigenen Verständnis zusammengestellt. Der Schlüssel zum Verständnis von Annotationen ist, ihre Syntax und Verwendung zu verstehen, und ich habe diese ausführlich erklärt. Nachdem Sie die Syntax und Verwendung verstanden haben, kann ein Blick auf das Framework-Diagramm Ihnen ein tieferes Verständnis vermitteln. Genug geschwafelt; beginnen wir mit der Erklärung von Annotationen. Wenn Sie Fehler oder Mängel im Artikel finden, weisen Sie bitte darauf hin!
Eingebaute Annotationen
Java definiert eine Reihe von Annotationen, insgesamt 7. 3 befinden sich in java.lang, und die restlichen 4 in java.lang.annotation.
Die Annotationen, die auf Code wirken, sind:
- @Override - Prüft, ob die Methode eine überschreibende Methode ist. Wenn festgestellt wird, dass die Elternklasse oder die referenzierte Schnittstelle diese Methode nicht besitzt, wird ein Kompilierungsfehler gemeldet.
- @Deprecated - Markiert eine Methode als veraltet. Wenn die Methode verwendet wird, wird eine Kompilierungswarnung gemeldet.
- @SuppressWarnings - Weist den Compiler an, die in der Annotation deklarierten Warnungen zu ignorieren.
Annotationen, die auf andere Annotationen (oder Meta-Annotationen) wirken, sind:
- @Retention – Legt fest, wie diese Annotation gespeichert wird: ob sie nur im Code vorhanden ist, in die Klassendatei kompiliert wird oder zur Laufzeit über Reflection zugänglich ist.
- @Documented – Kennzeichnet, ob diese Annotationen in die Benutzerdokumentation aufgenommen werden.
- @Target – Kennzeichnet, auf welche Art von Java-Element diese Annotation angewendet werden soll.
- @Inherited – Kennzeichnet, von welcher Annotation-Klasse diese Annotation geerbt wird (standardmäßig werden Annotationen nicht an Unterklassen vererbt).
Ab Java 7 wurden 3 zusätzliche Annotationen hinzugefügt:
- @SafeVarargs – Unterstützt ab Java 7, ignoriert Warnungen, die durch Aufrufe von Methoden oder Konstruktoren entstehen, die generische variable Parameter verwenden.
- @FunctionalInterface – Unterstützt ab Java 8, kennzeichnet eine anonyme Funktion oder ein funktionales Interface.
- @Repeatable – Unterstützt ab Java 8, gibt an, dass eine Annotation mehrfach in derselben Deklaration verwendet werden kann.
1. Annotation-Architektur

Daraus können wir ersehen:
(01) 1 Annotation ist mit 1 RetentionPolicy verknüpft.
Das kann man so verstehen: Jedes Annotation-Objekt hat ein eindeutiges RetentionPolicy-Attribut.(02) 1 Annotation ist mit 1~n ElementType verknüpft.
Es kann so verstanden werden: Jedes Annotation-Objekt kann mehrere ElementType-Attribute haben.
(03) Annotation hat viele Implementierungsklassen, darunter: Deprecated, Documented, Inherited, Override usw.
Jede Implementierungsklasse von Annotation ist "mit 1 RetentionPolicy verknüpft" und "mit 1~n ElementType verknüpft".
Im Folgenden werde ich zunächst die linke Hälfte des Framework-Diagramms (wie unten gezeigt) vorstellen, nämlich Annotation, RetentionPolicy und ElementType; dann werde ich Beispiele geben, um die Implementierungsklassen von Annotation zu erklären.

2. Komponenten von Annotation
Unter den Komponenten von Java Annotations gibt es 3 sehr wichtige grundlegende Klassen. Sie sind:
Annotation.java
public interface Annotation {
boolean equals(Object obj);
int hashCode();
String toString();
Class<? extends Annotation> annotationType();
}
ElementType.java
public enum ElementType {
TYPE, /* Klasse, Schnittstelle (einschließlich Annotationstyp) oder Enum-Deklaration */
FIELD, /* Felddeklaration (einschließlich Enum-Konstante) */
METHOD, /* Methodendeklaration */
PARAMETER, /* Parameterdeklaration */
CONSTRUCTOR, /* Konstruktordeklaration */
LOCAL_VARIABLE, /* Lokale Variablendeklaration */
ANNOTATION_TYPE, /* Annotationstypdeklaration */
PACKAGE /* Paketdeklaration */
}
RetentionPolicy.java
public enum RetentionPolicy {
SOURCE, /* Annotation-Informationen existieren nur während der Compilerverarbeitung; nachdem der Compiler fertig ist, existieren die Annotation-Informationen nicht mehr */
CLASS, /* Der Compiler speichert die Annotation in der .class-Datei, die der Klasse entspricht. Standardverhalten */
RUNTIME /* Der Compiler speichert die Annotation in der Klassendatei, und sie kann von der JVM gelesen werden */
}
Erklärung:
(01) Eine Annotation ist nur ein Interface.
"Jede Annotation" ist mit "1 RetentionPolicy" verknüpft und ist mit "1~n ElementType" verknüpft. Laienhaft ausgedrückt: Jedes Annotation-Objekt hat ein eindeutiges RetentionPolicy-Attribut; was das ElementType-Attribut betrifft, gibt es 1~n davon.
(02) ElementType ist ein Enum-Typ, der verwendet wird, um den Typ einer Annotation anzugeben.
"Jede Annotation" ist mit "1~n ElementType" verknüpft. Wenn eine Annotation mit einem bestimmten ElementType verknüpft ist, bedeutet das, dass die Annotation einen bestimmten Zweck hat. Wenn ein Annotation-Objekt beispielsweise vom Typ METHOD ist, kann die Annotation nur zum Modifizieren von Methoden verwendet werden.
(03) RetentionPolicy ist ein Enum-Typ, der verwendet wird, um die Policy einer Annotation anzugeben. Einfach ausgedrückt haben Annotationen unterschiedlicher RetentionPolicy-Typen unterschiedliche Gültigkeitsbereiche.
"Jede Annotation" ist mit "1 RetentionPolicy" verknüpft.
- a) Wenn der Typ der Annotation SOURCE ist, bedeutet das: Die Annotation existiert nur während der Compilerverarbeitung; nachdem der Compiler die Verarbeitung abgeschlossen hat, ist die Annotation nicht mehr nützlich. Zum Beispiel ist die Markierung "@Override" eine Annotation. Wenn sie eine Methode modifiziert, bedeutet das, dass die Methode eine Methode der übergeordneten Klasse überschreibt und während der Kompilierung eine Syntaxprüfung durchgeführt wird! Nachdem der Compiler die Verarbeitung abgeschlossen hat, hat "@Override" keine weitere Wirkung.
- b) Wenn der Typ der Annotation CLASS ist, bedeutet das: Der Compiler speichert die Annotation in der .class-Datei, die der Klasse entspricht. Dies ist das Standardverhalten von Annotation.
- c) Wenn der Typ der Annotation RUNTIME ist, bedeutet das: Der Compiler speichert die Annotation in der Klassendatei, und sie kann von der JVM gelesen werden.
An dieser Stelle müssen Sie sich nur merken, dass "jede Annotation" mit "1 RetentionPolicy" und mit "1~n ElementType" verknüpft ist. Nachdem Sie die folgenden Inhalte gelernt haben, wird ein Rückblick auf diesen Inhalt leichter zu verstehen sein.
3. Von Java bereitgestellte Annotationen
Nachdem wir die Rollen der 3 oben genannten Klassen verstanden haben, können wir nun die Syntaxdefinitionen der Annotation-Implementierungsklassen erläutern.
1) Allgemeine Definition von Annotation
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
}
Erklärung:
Das Obige wird verwendet, um eine Annotation namens MyAnnotation1 zu definieren. Nachdem MyAnnotation1 definiert wurde, können wir sie im Code über "@MyAnnotation1" verwenden. Die anderen, @Documented, @Target, @Retention, @interface, werden alle verwendet, um MyAnnotation1 zu modifizieren. Im Folgenden erläutern wir ihre Bedeutungen jeweils:
(01) @interface
Wenn @interface verwendet wird, um eine Annotation zu definieren, bedeutet das, dass sie die Schnittstelle java.lang.annotation.Annotation implementiert, d. h., die Annotation ist eine Annotation.
Beim Definieren einer Annotation ist @interface erforderlich.Hinweis: Dies unterscheidet sich von unserer üblichen Art, Schnittstellen mit "implements" zu implementieren. Die Implementierungsdetails der Annotation-Schnittstelle werden alle vom Compiler erledigt. Nachdem eine Annotation mit @interface definiert wurde, kann die Annotation keine anderen Annotationen oder Schnittstellen erben.
(02) @Documented
Standardmäßig erscheinen Annotationen an Klassen und Methoden nicht in javadoc. Wenn die Annotation mit @Documented modifiziert wird, bedeutet das, dass sie in javadoc erscheinen kann.
Beim Definieren einer Annotation ist @Documented optional; wenn es nicht definiert ist, erscheint die Annotation nicht in javadoc.
(03) @Target(ElementType.TYPE)
Zuvor haben wir gesagt, dass ElementType das Typ-Attribut einer Annotation ist. Und die Rolle von @Target besteht darin, das Typ-Attribut der Annotation anzugeben.
@Target(ElementType.TYPE) bedeutet, dass der Typ dieser Annotation ElementType.TYPE ist. Das bedeutet, dass MyAnnotation1 eine Annotation ist, die verwendet wird, um „Klassen-, Interface- (einschließlich Annotationstypen) oder Enum-Deklarationen“ zu modifizieren.
Beim Definieren einer Annotation ist @Target optional. Wenn @Target vorhanden ist, kann die Annotation nur an den Stellen verwendet werden, die @Target angibt; wenn kein @Target vorhanden ist, kann die Annotation überall verwendet werden.
(04) @Retention(RetentionPolicy.RUNTIME)
Zuvor haben wir gesagt, dass RetentionPolicy das Strategie-Attribut einer Annotation ist, und die Rolle von @Retention besteht darin, das Strategie-Attribut der Annotation anzugeben.
@Retention(RetentionPolicy.RUNTIME) bedeutet, dass die Strategie dieser Annotation RetentionPolicy.RUNTIME ist. Das bedeutet, dass der Compiler die Annotation-Informationen in der .class-Datei beibehält und sie von der virtuellen Maschine gelesen werden können.
Beim Definieren einer Annotation ist @Retention optional. Wenn kein @Retention vorhanden ist, ist der Standardwert RetentionPolicy.CLASS.
2) Von Java bereitgestellte Annotationen
Anhand der obigen Beispiele können wir verstehen: @interface wird verwendet, um eine Annotation zu deklarieren, @Documented wird verwendet, um anzugeben, ob die Annotation in javadoc erscheint, @Target wird verwendet, um den Typ der Annotation anzugeben, und @Retention wird verwendet, um die Strategie der Annotation anzugeben.
Nachdem wir dies verstanden haben, können wir leicht die Implementierungsklassen der Annotationen verstehen, die mit Java geliefert werden, das heißt die rechte Hälfte des Annotation-Architekturdiagramms. Wie unten dargestellt:

Häufig verwendete Annotationen in Java:
@Deprecated -- @Deprecated 所标注内容,不再被建议使用。 @Override -- @Override 只能标注方法,表示该方法覆盖父类中的方法。 @Documented -- @Documented 所标注内容,可以出现在javadoc中。 @Inherited -- @Inherited只能被用来标注“Annotation类型”,它所标注的Annotation具有继承性。 @Retention -- @Retention只能被用来标注“Annotation类型”,而且它被用来指定Annotation的RetentionPolicy属性。 @Target -- @Target只能被用来标注“Annotation类型”,而且它被用来指定Annotation的ElementType属性。 @SuppressWarnings -- @SuppressWarnings 所标注内容产生的警告,编译器会对这些警告保持静默。
Da "@Deprecated und @Override" ähnlich sind und "@Documented, @Inherited, @Retention, @Target" ähnlich sind; im Folgenden werden wir nur die drei Annotationen erklären: @Deprecated, @Inherited und @SuppressWarnings.
2.1) @Deprecated
Die Definition von @Deprecated lautet wie folgt:
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}
Erklärung:
- (01) @interface -- Es wird verwendet, um Deprecated zu modifizieren, was bedeutet, dass Deprecated die Schnittstelle java.lang.annotation.Annotation implementiert; das heißt, Deprecated ist eine Annotation. (02) @Documented -- Seine Rolle besteht darin anzuzeigen, dass diese Annotation in javadoc erscheinen kann.
- (03) @Retention(RetentionPolicy.RUNTIME) -- Seine Rolle besteht darin festzulegen, dass die Strategie von Deprecated RetentionPolicy.RUNTIME ist. Das bedeutet, dass der Compiler die Informationen von Deprecated in der .class-Datei beibehält und sie von der virtuellen Maschine gelesen werden können.
- (04) Der mit @Deprecated gekennzeichnete Inhalt wird nicht mehr zur Verwendung empfohlen.
Zum Beispiel: Wenn eine Methode mit @Deprecated markiert ist, wird diese Methode nicht mehr zur Verwendung empfohlen. Wenn ein Entwickler versucht, eine mit @Deprecated markierte Methode zu verwenden oder zu überschreiben, gibt der Compiler entsprechende Hinweismeldungen aus. Ein Beispiel ist wie folgt:

DeprecatedTest.java
import java.util.Calendar;
public class DeprecatedTest {
// @Deprecated modifiziert getString1(), was anzeigt, dass es sich um eine Funktion handelt, deren Verwendung nicht empfohlen wird
@Deprecated
private static void getString1(){
System.out.println("Veraltete Methode");
}
private static void getString2(){
System.out.println("Normale Methode");
}
// Date ist eine Datum/Zeit-Klasse. Java empfiehlt nicht mehr, diese Klasse zu verwenden.
private static void testDate() {
Date date = new Date(113, 8, 25);
System.out.println(date.getYear());
}
// Calendar ist eine Datum/Zeit-Klasse. Java empfiehlt, Calendar anstelle von Date zu verwenden, um "Datum/Zeit" darzustellen.
private static void testCalendar() {
Calendar cal = Calendar.getInstance();
System.out.println(cal.get(Calendar.YEAR));
}
public static void main(String[] args) {
getString1();
getString2();
testDate();
testCalendar();
}
}
Erklärung:
Das Obige ist ein Screenshot aus Eclipse, der "getString1() und getString2()" sowie "testDate() und testCalendar()" in der Klasse vergleicht.
(01) getString1() ist mit @Deprecated markiert, was bedeutet, dass getString1() nicht mehr zur Verwendung empfohlen wird; daher sind sowohl die Definition als auch der Aufruf von getString1() durchgestrichen. Diese Durchstreichung ist die Art und Weise, wie Eclipse Methoden behandelt, die mit @Deprecated markiert sind.
getString2() ist nicht mit @Deprecated markiert, daher ist seine Anzeige normal.
(02) testDate() ruft Methoden im Zusammenhang mit Date auf, aber Java hat von der Verwendung von Date für Datums-/Zeitoperationen abgeraten. Daher werden beim Aufruf der API von Date Warnmeldungen erzeugt, nämlich die Warnungen in der Abbildung.
testCalendar() ruft die API von Calendar auf, um Datum/Zeit zu bearbeiten. Java empfiehlt die Verwendung von Calendar anstelle von Date. Daher erzeugt das Arbeiten mit Calendar keine Warnung.
2.2) @Inherited
Die Definition von @Inherited ist wie folgt:
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}
Erklärung:
- (01) @interface -- Es wird verwendet, um Inherited zu modifizieren, was bedeutet, dass Inherited das Interface java.lang.annotation.Annotation implementiert; das heißt, Inherited ist eine Annotation.
- (02) @Documented -- Ihre Rolle besteht darin, anzugeben, dass diese Annotation in javadoc erscheinen kann.
- (03) @Retention(RetentionPolicy.RUNTIME) -- Ihre Rolle besteht darin, anzugeben, dass die Strategie von Inherited RetentionPolicy.RUNTIME ist. Das bedeutet, dass der Compiler die Informationen von Inherited in der .class-Datei beibehält und sie von der virtuellen Maschine gelesen werden können.
- (04) @Target(ElementType.ANNOTATION_TYPE) -- Seine Rolle besteht darin, anzugeben, dass der Typ von Inherited ANNOTATION_TYPE ist. Das bedeutet, dass @Inherited nur verwendet werden kann, um "Annotationstypen" zu annotieren.
- (05) Die Bedeutung von @Inherited ist, dass die Annotation, die es annotiert, über Vererbung verfügt.
MyAnnotation, dann "hat Base die Annotation MyAnnotation"; nun erbt Sub von Base, und weil MyAnnotation @Inherited ist (Vererbung hat), "hat Sub auch die Annotation MyAnnotation".
Beispiel für die Verwendung von @Inherited:
InheritableSon.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
/**
* Benutzerdefinierte Annotation.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface Inheritable
{
}
@Inheritable
class InheritableFather
{
public InheritableFather() {
// Ob InheritableBase die Inheritable-Annotation hat
System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
}
}
/**
* Die Klasse InheritableSon erbt lediglich von InheritableFather,
*/
public class InheritableSon extends InheritableFather
{
public InheritableSon() {
super(); // Konstruktor der Elternklasse aufrufen
// Ob die Klasse InheritableSon die Inheritable-Annotation besitzt
System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
}
public static void main(String[] args)
{
InheritableSon ist = new InheritableSon();
}
}
Run result:
InheritableFather:true InheritableSon:true
Jetzt ändern wir InheritableSon.java: Kommentieren wir die "@Inherited-Annotation von Inheritable" aus.
InheritableSon.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
/**
* Benutzerdefinierte Annotation.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
//@Inherited
@interface Inheritable
{
}
@Inheritable
class InheritableFather
{
public InheritableFather() {
// Ob InheritableBase die Inheritable-Annotation hat
System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
}
}
/**
* Die Klasse InheritableSon erbt lediglich von InheritableFather,
*/
public class InheritableSon extends InheritableFather
{
public InheritableSon() {
super(); // Ruft den Konstruktor der Elternklasse auf
// Ob die Klasse InheritableSon die Inheritable-Annotation besitzt
System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
}
public static void main(String[] args)
{
InheritableSon ist = new InheritableSon();
}
}
Ausgabe:
InheritableFather:true InheritableSon:false
Wenn wir die beiden obigen Ergebnisse vergleichen, stellen wir fest, dass die Inheritable-Annotation, wenn sie mit @Inherited markiert ist, Vererbung besitzt. Andernfalls hat sie keine Vererbung.
2.3) @SuppressWarnings
Die Definition von @SuppressWarnings lautet wie folgt:
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
String[] value();
}
Erklärung:
(01) @interface -- Es wird verwendet, um SuppressWarnings zu modifizieren, was bedeutet, dass SuppressWarnings das Interface java.lang.annotation.Annotation implementiert; das heißt, SuppressWarnings ist eine Annotation.
(02) @Retention(RetentionPolicy.SOURCE) -- Ihr Zweck ist anzugeben, dass die Richtlinie von SuppressWarnings RetentionPolicy.SOURCE ist. Das bedeutet, dass die SuppressWarnings-Informationen nur während der Compilerverarbeitung existieren; nachdem der Compiler die Verarbeitung beendet hat, hat SuppressWarnings keine Wirkung.
(03) @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) -- Ihr Zweck ist anzugeben, dass die Typen von SuppressWarnings TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE umfassen.
- TYPE bedeutet, dass es "Klassen, Schnittstellen (einschließlich Annotationstypen) oder Enum-Deklarationen" annotieren kann.
- FIELD bedeutet, dass es "Felddeklarationen" annotieren kann.
- METHOD bedeutet, dass es "Methoden" annotieren kann.
- PARAMETER bedeutet, dass es "Parameter" annotieren kann.
- CONSTRUCTOR bedeutet, dass es "Konstruktoren" annotieren kann.
- LOCAL_VARIABLE bedeutet, dass es "lokale Variablen" annotieren kann.
(04) String[] value(); bedeutet, dass SuppressWarnings Parameter angeben kann.
(05) Der Zweck von SuppressWarnings besteht darin, den Compiler bezüglich bestimmter Warnungen in dem von ihm annotierten Inhalt schweigen zu lassen. Zum Beispiel bedeutet "@SuppressWarnings(value={"deprecation", "unchecked"})", dass bezüglich der "Deprecation-Warnungen" und "Unchecked-Conversion-Warnungen" im annotierten Inhalt geschwiegen wird. Beispiel:


SuppressWarningTest.java
public class SuppressWarningTest {
//@SuppressWarnings(value={"deprecation"})
public static void doSomething(){
Date date = new Date(113, 8, 26);
System.out.println(date);
}
public static void main(String[] args) {
doSomething();
}
}
Erklärung:
(01) In der linken Abbildung wird @SuppressWarnings(value={"deprecation"}) nicht verwendet, und Date ist eine Klasse, deren Verwendung Java nicht mehr empfiehlt. Daher erzeugt der Aufruf der Date-API eine Warnung. In der rechten Abbildung wird @SuppressWarnings(value={"deprecation"}) verwendet. Daher schweigt der Compiler über die "Warnung, die durch den Aufruf der Date-API erzeugt wird".
Ergänzung: Tabelle der häufig verwendeten Schlüsselwörter für SuppressWarnings
deprecation -- 使用了不赞成使用的类或方法时的警告 unchecked -- 执行了未检查的转换时的警告,例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型。 fallthrough -- 当 Switch 程序块直接通往下一种情况而没有 Break 时的警告。 path -- 在类路径、源文件路径等中有不存在的路径时的警告。 serial -- 当在可序列化的类上缺少 serialVersionUID 定义时的警告。 finally -- 任何 finally 子句不能正常完成时的警告。 all -- 关于以上所有情况的警告。
4. Die Rolle der Annotation
Annotation ist eine Hilfsklasse, die in Tool-Frameworks wie Junit, Struts und Spring weit verbreitet ist.
Zu den Annotation-Funktionen, die wir bei der Programmierung häufig verwenden, gehören:
1) Überprüfung zur Kompilierungszeit
Annotation hat die "Funktion, den Compiler Kompilierungsprüfungen durchführen zu lassen".
Zum Beispiel haben @SuppressWarnings, @Deprecated und @Override alle Funktionen zur Kompilierungsprüfung.
(01) @SuppressWarnings und @Deprecated wurden bereits in "Teil 3" ausführlich beschrieben. Weitere Beispiele werden hier nicht gegeben.
(02) Wenn eine Methode mit @Override markiert ist, bedeutet das, dass die Methode eine Methode mit demselben Namen in der Elternklasse überschreibt. Wenn eine Methode mit @Override markiert ist, aber die Elternklasse keine Methode mit demselben Namen hat, die "mit @Override markiert ist", meldet der Compiler einen Fehler. Beispiel:

OverrideTest.java
/**
* toString() ist in java.lang.Object definiert;
* Daher ist die Verwendung von @Override hier korrekt.
*/
@Override
public String toString(){
return "Override toString";
}
/**
* getString() ist in keiner Elternklasse von OverrideTest definiert;
* Allerdings ist es hier mit @Override markiert, sodass ein Kompilierungsfehler auftritt!
*/
@Override
public String getString(){
return "get toString";
}
public static void main(String[] args) {
}
}
Das Obige ist ein Screenshot des Programms in Eclipse. Daraus können wir ersehen, dass die Funktion "getString()" einen Fehler melden wird. Das liegt daran, dass "getString() mit @Override markiert ist, aber getString1() in keiner Elternklasse von OverrideTest definiert ist".
Wenn man "@Override über getString()" auskommentiert, wird der Fehler behoben.
2) Verwendung von Annotationen in der Reflection
In Reflexionsfunktionen wie Class, Method und Field gibt es viele Schnittstellen, die sich auf Annotation beziehen.
Das bedeutet auch, dass wir Annotation in der Reflexion parsen und verwenden können.
AnnotationTest.java
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
import java.lang.reflect.Method;
/**
* Beispiel für die Verwendung von Annotation in Reflexionsfunktionen
*/
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
String[] value() default "unknown";
}
/**
* Person-Klasse. Sie wird die Annotation MyAnnotation verwenden.
*/
class Person {
/**
* Die Methode empty() ist sowohl mit "@Deprecated" als auch mit "@MyAnnotation(value={"a","b"})" markiert
* (01) @Deprecated bedeutet, dass die Methode empty() nicht mehr zur Verwendung empfohlen wird
* (02) @MyAnnotation bedeutet, dass der Wert von MyAnnotation, der der Methode empty() entspricht, der Standardwert "unknown" ist
*/
@MyAnnotation
@Deprecated
public void empty(){
System.out.println("\nempty");
}
/**
* sombody() wird durch @MyAnnotation(value={"girl","boy"}) markiert,
* @MyAnnotation(value={"girl","boy"}) bedeutet, dass der Wert von MyAnnotation {"girl","boy"} ist
*/
@MyAnnotation(value={"girl","boy"})
public void somebody(String name, int age){
System.out.println("\nsomebody: "+name+", "+age);
}
}
public class AnnotationTest {
public static void main(String[] args) throws Exception {
// Erstelle eine neue Person
Person person = new Person();
// Class-Instanz von Person abrufen
Class<Person> c = Person.class;
// Method-Instanz der somebody()-Methode abrufen
Method mSomebody = c.getMethod("somebody", new Class[]{String.class, int.class});
// Methode ausführen
mSomebody.invoke(person, new Object[]{"lily", 18});
iteratorAnnotations(mSomebody);
// Method-Instanz der somebody()-Methode abrufen
Method mEmpty = c.getMethod("empty", new Klasse[]{});
// Methode ausführen
mEmpty.invoke(person, new Object[]{});
iteratorAnnotations(mEmpty);
}
public static void iteratorAnnotations(Method method) {
// Ermitteln, ob die somebody()-Methode die Annotation MyAnnotation enthält
if(method.isAnnotationPresent(MyAnnotation.class)){
// Hole die MyAnnotation-Annotationsinstanz der Methode
MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
// Hole den Wert von myAnnotation und gib ihn aus
String[] values = myAnnotation.value();
for (String str:values)
System.out.printf(str+", ");
System.out.println();
}
// Hole alle Annotationen der Methode und gib sie aus
Annotation[] annotations = method.getAnnotations();
for(Annotation annotation : annotations){
System.out.println(annotation);
}
}
}
Ausgabe:
somebody: lily, 18 girl, boy, @com.skywang.annotation.MyAnnotation(value=[girl, boy]) empty unknown, @com.skywang.annotation.MyAnnotation(value=[unknown]) @java.lang.Deprecated()
3) Generieren von Hilfedokumentation basierend auf Annotationen
Durch Hinzufügen des Tags @Documented zu einer Annotation kann das Annotation-Tag in javadoc erscheinen.
4) Hilfreich beim Anzeigen von Code
Durch @Override, @Deprecated usw. können wir die allgemeine Struktur eines Programms leicht verstehen.
Darüber hinaus können wir auch einige Funktionen durch benutzerdefinierte Annotation implementieren.
Originaladresse: https://www.cnblogs.com/skywang12345/p/3344137.html