Vertiefendes Verständnis von Java: Grundkonzepte der Annotation

Was ist Annotation (Annotation):

Annotation (Annotation) ist, dass Java eine Möglichkeit und Methode für Elemente in einem Metaprogramm bereitstellt, beliebige Informationen und beliebige Metadaten (Metadaten) 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 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 von 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.

Annotation kann verwendet werden, um beliebige Informationen einem bestimmten Programmelement (Klasse, Methode, Mitgliedsvariable usw.) zuzuordnen. 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 aus dem Wort Metadaten übersetzt, was „Daten über Daten“ bedeutet.
Metadaten haben viele Funktionen. Beispielsweise haben Sie möglicherweise Javadoc-Kommentare verwendet, um Dokumente automatisch 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 möchten, gibt es derzeit keine klare Definition, aber wir können sie basierend auf ihrer Rolle grob in drei Kategorien einteilen:
　1. Schreiben von Dokumenten: Erzeugt durch im Code identifizierte Metadaten Dokument
2. Code-Analyse: Analysieren Sie den Code anhand der im Code identifizierten Metadaten
3. Kompilierungsprüfung: Die im Code identifizierten Metadaten ermöglichen dem Compiler die Implementierung grundlegender Kompilierungsprüfungen
In Java liegen Metadaten im Java-Code in der Form vor von Tags. Das Vorhandensein von Metadaten-Tags hat keinen Einfluss auf die Kompilierung und Ausführung von Programmcode. Sie werden nur zur Generierung anderer Dateien oder zur Kenntnis der Beschreibungsinformationen des zur Laufzeit ausgeführten Codes verwendet.
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, um andere Programmkomponenten zu generieren.
Viertens können Metadaten nur auf der Ebene des Java-Quellcodes oder innerhalb der kompilierten Klassendatei vorhanden sein.

---

Annotation und Annotation-Typ:

Annotation:

Annotation verwendet die neue Syntax von Java5.0. Ihr Verhalten ist dem öffentlichen und finalen Modifikator dieser Art 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.

Annotationstyp:

Der Annotation-Typ 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.

---

Anmerkungsklassifizierung:

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. Zum Beispiel die folgende Systemanmerkung @Override;
2. Einzelwertanmerkung
3. Vollständige Annotation

Entsprechend der Verwendung und dem Zweck der Annotation können wir die Annotation in drei Kategorien einteilen:
1. JDK-integrierte Systemanmerkungen
2. Meta-Anmerkungen
3. Benutzerdefinierte Anmerkungen

---

Systemintegrierte Standardanmerkungen:

Die Anmerkungssyntax ist relativ einfach Mit Ausnahme der Verwendung des @-Symbols entspricht es im Wesentlichen der inhärenten Syntax von Java. In JavaSE sind drei Standardanmerkungen integriert, die in java.lang definiert sind:
@Override: wird zum Ändern verwendet Methode, um die Methode der übergeordneten Klasse abzudecken;
@Deprecated: Wird zum Ändern veralteter Methoden verwendet.
@SuppressWarnings: Wird verwendet, um den Java-Compiler zu benachrichtigen, bestimmte Kompilierungswarnungen zu unterdrücken.

Werfen wir nacheinander einen Blick auf die Funktionen und Verwendungsszenarien der drei integrierten Standardanmerkungen.

---

@Override, beschränkt auf das Überschreiben von Methoden der übergeordneten Klasse:

@Override ist ein Markierungsanmerkungstyp, der als Anmerkungsmethode 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 eines Versuchs, die displayName()-Methode einer übergeordneten Klasse zu überschreiben, jedoch mit einem Tippfehler:

public class Fruit {

    public void displayName(){
        System.out.println("水果的名字是：*****");
    }
}

class Orange extends Fruit {
    @Override
    public void displayName(){
        System.out.println("水果的名字是：桔子");
    }
}

class Apple extends Fruit {
    @Override
    public void displayname(){
        System.out.println("水果的名字是：苹果");
    }
}

　 Orange 类编译不会有任何问题，Apple 类在编译的时候会提示相应的错误。@Override注解只能用于方法，不能用于其他程序元素。

---

@Deprecated, das Tag ist veraltet:

Ebenso ist Deprecated auch eine Tag-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 verwendet wird Erstellen Sie Dokumente (einschließlich Programme). Eine Beschreibung, warum das Mitglied veraltet ist und wie es gesperrt oder ersetzt werden sollte.

In Java 5.0 sucht der Java-Compiler weiterhin wie in früheren Versionen nach den @deprecated-Javadoc-Tags und verwendet sie zum Generieren von Warnmeldungen. Aber diese Situation wird sich 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 veraltet zu markieren folgt:

 class AppleService {
    public void displayName(){
        System.out.println("水果的名字是：苹果");
    }
    
    /**
     * @deprecated 该方法已经过期，不推荐使用
     */
    @Deprecated
    public void showTaste(){
        System.out.println("水果的苹果的口感是：脆甜");
    }
    
    public void showTaste(int typeId){
        if(typeId==1){
            System.out.println("水果的苹果的口感是：酸涩");
        }
        else if(typeId==2){
            System.out.println("水果的苹果的口感是：绵甜");
        }
        else{
            System.out.println("水果的苹果的口感是：脆甜");
        }
    }
}

public class 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);
    }

}

　　AppleService类的showTaste() 方法被@Deprecated标注为过时方法，在FruitRun类中使用的时候，编译器会给出该方法已过期，不推荐使用的提示。

---

SuppressWarnnings，抑制编译器警告：

　　@SuppressWarnings 被用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告。在java5.0，sun提供的javac编译器为我们提供了-Xlint选项来使编译器对合法的程序代码提出警告，此种警告从某种程度上代表了程序错误。例如当我们使用一个generic collection类而又没有提供它的类型时，编译器将提示出"unchecked warning"的警告。通常当这种情况发生时，我们就需要查找引起警告的代码。如果它真的表示错误，我们就需要纠正它。例如如果警告信息表明我们代码中的switch语句没有覆盖所有可能的case，那么我们就应增加一个默认的case来避免这种警告。
　　有时我们无法避免这种警告，例如，我们使用必须和非generic的旧代码交互的generic collection类时，我们不能避免这个unchecked warning。此时@SuppressWarning就要派上用场了，在调用的方法前增加@SuppressWarnings修饰，告诉编译器停止对此方法的警告。
　　SuppressWarning不是一个标记注解。它有一个类型为String[]的成员，这个成员的值为被禁止的警告名。对于javac编译器来讲，被-Xlint选项有效的警告 名也同样对@SuppressWarings有效，同时编译器忽略掉无法识别的警告名。
　　annotation语法允许在annotation名后跟括号，括号中是使用逗号分割的name=value对用于为annotation的成员赋值。实例如下：

public class FruitService {
    
    @SuppressWarnings(value={ "rawtypes", "unchecked" })
    public static  List<fruit> getFruitList(){
        List<fruit> fruitList=new ArrayList();
        return fruitList;
    }
    
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static  List<fruit> getFruit(){
        List<fruit> fruitList=new ArrayList();
        return fruitList;
    }

    @SuppressWarnings("unused")
    public static void main(String[] args){
        List<string> strList=new ArrayList<string>();
    }
}</string></string></fruit></fruit></fruit></fruit>

　　在这个例子中SuppressWarnings annotation类型只定义了一个单一的成员，所以只有一个简单的value={...}作为name=value对。又由于成员值是一个数组，故使用大括号来声明数组值。注意：我们可以在下面的情况中缩写annotation：当annotation只有单一成员，并成员命名为"value="。这时可以省去"value="。比如将上面方法getFruit()的SuppressWarnings annotation就是缩写的。

 　 SuppressWarnings注解的常见参数值的简单说明：

　　　　1.deprecation：使用了不赞成使用的类或方法时的警告；
　　　　2.unchecked：执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型; 
　　　　3.fallthrough：当 Switch 程序块直接通往下一种情况而没有 Break 时的警告;
　　　　4.path：在类路径、源文件路径等中有不存在的路径时的警告; 
　　　　5.serial：当在可序列化的类上缺少 serialVersionUID 定义时的警告; 
　　　　6.finally：任何 finally 子句不能正常完成时的警告; 

　　　　7.all：关于以上所有情况的警告。

学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群：159610322   我们一起学Java！

Das obige ist der detaillierte Inhalt vonVertiefendes Verständnis von Java: Grundkonzepte der Annotation. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!