09.Java-Grundlagen – Anmerkungen

Grundlegende Konzepte

Annotation (Annotation) ist eine Schnittstelle, über die das Programm das Annotation-Objekt des angegebenen Programmelements abrufen kann Reflektion Rufen Sie dann die Metadaten in der Annotation über das Annotation-Objekt ab.

Je nach Verwendung und Zweck von Anmerkungen können wir Anmerkungen in drei Kategorien einteilen: Systemanmerkungen, Metaanmerkungen und benutzerdefinierte Anmerkungen.

---

Systemanmerkungen

Systemanmerkungen sind die integrierten JDK-Anmerkungen, hauptsächlich einschließlich: @Override, @Deprecated, @SuppressWarnings.

1.@Override

Beim Ändern einer Methode bedeutet dies, dass die Methode die Methode der übergeordneten Klasse oder die Methode, die die Schnittstelle implementiert, überschreibt

interface Demo{    public void print();
}public class Test implements Demo{
    @Override
    public void print() {
    }
}

---

2. @Deprecated

Veraltete Methoden ändern

---

3 . @SuppressWarnnings

Compiler-Warnungen unterdrücken, also Warnungen entfernen.

Gemeinsame Parameterwerte sind:

名称	作用
rawtypes	表示传参时也要传递带泛型的参数
deprecation	使用了不赞成使用的类或方法时的警告
unchecked	执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型
fallthrough	当 Switch 程序块直接通往下一种情况而没有 Break 时的警告;
path	在类路径、源文件路径等中有不存在的路径时的警告;
serial	当在可序列化的类上缺少 serialVersionUID 定义时的警告;
finally	任何 finally 子句不能正常完成时的警告;
all	关于以上所有情况的警告。

Beispiele sind wie folgt:

// 抑制单类型@SuppressWarnings("unchecked")public void print() {    @SuppressWarnings("rawtypes")
    List list = new ArrayList(); 
    list.add("a");
}// 抑制多类型@SuppressWarnings({ "unchecked", "rawtypes" })public void print() {
    List list = new ArrayList(); 
    list.add("a");
}// 抑制所有类型@SuppressWarnings({ "all" })public void print() {
    List list = new ArrayList(); 
    list.add("a");
}

---

Meta Annotation

Die Rolle von Meta-Anmerkungen besteht darin, andere Anmerkungen zu kommentieren. Java5.0 definiert 4 Standard-Meta-Annotation-Typen, die zur Bereitstellung von Beschreibungen anderer Annotationstypen verwendet werden.

Die definierten Meta-Anmerkungen lauten wie folgt: @Target, @Retention, @Documented, @Inherited.

---

1.@Target

@Target definiert den Umfang der durch Annotation geänderten Objekte:

public enum ElementType {    // 用于描述类、接口(包括注解类型) 或enum声明
    TYPE,    // 用于描述域（即变量）
    FIELD,    // 用于描述方法
    METHOD,    // 用于描述参数
    PARAMETER,    // 用于描述构造器
    CONSTRUCTOR,    // 用于描述局部变量
    LOCAL_VARIABLE,    // 用于描述注解类型
    ANNOTATION_TYPE,    // 用于描述包
    PACKAGE
}

---

2.@Retention

@Retention definiert den Zeitraum, für den die Annotation aufbewahrt wird, d. h. sie gibt den Lebenszyklus der Annotation an.

public enum RetentionPolicy {    // 在源文件中有效（编译器要丢弃的注解）
    SOURCE,    // class 文件中有效（默认，编译器将把注解记录在类文件中，但在运行时 VM 不需要保留注解）
    CLASS,    // 在运行时有效（编译器将把注解记录在类文件中，在运行时 VM 将保留注解，因此可以反射性地读取）
    RUNTIME
}

---

3.@Documented

@Documented definiert Annotation und gibt an, dass eine bestimmte Art von Annotation über Javadoc und ähnliche Standardtools dokumentiert wird.

Wenn eine Typdeklaration mit Documented annotiert ist, wird ihre Annotation Teil der öffentlichen API des annotierten Elements.

---

4.@Inherited

@Inherited definiert Annotation und gibt an, dass der Annotationstyp automatisch geerbt wird, dh ein mit @Inherited geänderter Annotationstyp ist Wird eine Klasse verwendet, wird diese Annotation für Unterklassen dieser Klasse verwendet.

• Bei Verwendung eines Annotationstyps zum Annotieren von etwas anderem als der Klasse ist @Inherited ungültig.

• Diese Metaanmerkung ermöglicht nur die Vererbung von Anmerkungen von der übergeordneten Klasse. Anmerkungen zu implementierten Schnittstellen sind nicht gültig.

• Wenn die Aufbewahrung der mit dem Annotationstyp @Inherited annotierten Annotation RetentionPolicy.RUNTIME ist, verbessert die Reflektion-API diese Vererbung. Wenn wir java.lang.reflect verwenden, um Annotationen eines @Inherited-Annotationstyps abzufragen, beginnt die reflektierende Codeinspektion zu funktionieren: Überprüfen Sie die Klasse und ihre übergeordnete Klasse, bis der angegebene Annotationstyp oder die oberste Ebene der Klassenvererbungsstruktur gefunden wird erreicht ist

Beispiele sind wie folgt:

// 定义注解@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)@Inherited@interface MyAnotation{    
public String name();
}// 作用在类上@MyAnotation(name="parent")
class Parent{

}// 继承 Parent 类public class Test extends Parent{
    public static void main(String[] args) {
        Class<?> cls = Test.class;        // 通过 @Inherited 继承父类的注解
        Annotation annotation = cls.getAnnotation(MyAnotation.class);
        MyAnotation myAnotation = (MyAnotation) annotation;
        System.out.println(myAnotation.name());
    }
}// 输出结果：parent（若注释掉注解，返回异常）

---

Benutzerdefinierte Anmerkung

1. Klassenanmerkung

// 定义注解@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)@interface MyAnnotation {    
public String name();    public String age();
}// 调用注解@MyAnnotation(name="cook",age="100")public class Test {
    public static void main(String[] args) {
        Class<?> cls = Test.class;        // 1.取得所有注解
        Annotation[] annotations =cls.getAnnotations();        // 2.取得指定注解
        MyAnnotation annotation = 
            (MyAnnotation)cls.getAnnotation(MyAnnotation.class);
    }
}

---

2. Methodenanmerkungen

// 定义注解@Retention(RetentionPolicy.RUNTIME)
// 修改作用范围@Target(ElementType.METHOD)@interface MyAnnotation {    public String name();    public String age();
}
// 调用注解public class Test {

    public static void main(String[] args) throws Exception {
        Class cls = Test.class;
        Method method = cls.getDeclaredMethod("print", null);        // 1.取得所有注解
        Annotation[] annotations = method.getDeclaredAnnotations();        // 2.取得指定注解
        MyAnnotation annotation = 
            (MyAnnotation)method.getAnnotation(MyAnnotation.class);
    }

---

3 🎜>

// 定义注解@Retention(RetentionPolicy.RUNTIME)
// 修改作用范围@Target(ElementType.PARAMETER)@interface MyAnnotation {    public String name();    public String age();
}public class Test {

    public static void main(String[] args) throws Exception {
        Class cls = Test.class;
        Method method = cls.getDeclaredMethod("print", new Class[]{String.class,String.class});
        getAllAnnotations(method);
    }    // 作用在参数上
    public void print(@MyAnnotation(name = "cook", age = "100") 
        String name, String age) { }    public static void getAllAnnotations(Method method) {
        Annotation[][] parameterAnnotions = method.getParameterAnnotations();        
        // 通过反射只能取得所有参数类型，不能取得指定参数
        Class[] paraemterTypes = method.getParameterTypes();        
        int i = 0;        
        for (Annotation[] annotations : parameterAnnotions) {
            Class paraemterType = paraemterTypes[i++];            
            for (Annotation annotation : annotations) {                
            if (annotation instanceof MyAnnotation) {
                    MyAnnotation myAnnotation = (MyAnnotation) annotation;
                    System.out.println(paraemterType.getName());
                    System.out.println(myAnnotation.name());
                    System.out.println(myAnnotation.age());
                }
            }
        }
    }
}

---

4. Variable Anmerkungen

Das Obige ist der Inhalt von 09.Java-Grundlagen – Anmerkungen, bitte bezahlen Achtung auf die chinesische PHP-Website (www.php.cn)!

// 定义注解@Retention(RetentionPolicy.RUNTIME)
// 修改作用范围@Target(ElementType.FIELD)@interface MyAnnotation {    public String name();    public String age();
}public class Test {
    // 作用在变量上
    @MyAnnotation(name = "cook", age = "100")    
    private String name;    
    public static void main(String[] args) throws Exception {
        Class cls = Test.class;
        Field field = cls.getDeclaredField("name");
        Annotation[] fieldAnnotions = field.getDeclaredAnnotations();
        MyAnnotation annotation = 
            (MyAnnotation) field.getAnnotation(MyAnnotation.class);
    }
}