09.Java Basics - Annotations-javaTutorial-php.cn

Basic concept

Annotation (annotation) is an interface. The program can obtain the Annotion object of the specified program element through reflection. Then obtain the metadata in the annotation through the Annotation object.

According to the usage and purpose of annotations, we can divide Annotations into three categories: system annotations, meta-annotations, and custom annotations.

System annotations

System annotations, namely JDK built-in annotations, mainly include: @Override, @Deprecated, @SuppressWarnings.

1.@Override

When modifying a method, it means that the method overrides the method of the parent class or the method of implementing the interface

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

Copy after login

2.@Deprecated

Modify obsolete methods

Alt text

3.@SuppressWarnings

Suppress compiler warnings, that is, remove warnings.

Common parameter values are:

Name	Function
rawtypes	Indicates that generic parameters must also be passed when passing parameters
deprecation	Using a deprecated class or method Warnings when
unchecked	Warnings when unchecked conversions are performed, such as when using collections without using generics to specify the type of collection saved.
fallthrough	Warning when the Switch block leads directly to the next situation without Break;
path	Warning when there are non-existent paths in the class path, source file path, etc.;
serial	When in the serializable class Warning when serialVersionUID definition is missing;
finally	Warning when any finally clause cannot be completed normally;
all	Warning regarding all of the above.

Examples are as follows:

// 抑制单类型@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");
}

Copy after login

Meta-annotations

The role of meta-annotations is to annotate other annotation. Java5.0 defines 4 standard meta-annotation types, which are used to provide descriptions of other annotation types.

The defined meta-annotations are as follows: @Target, @Retention, @Documented, @Inherited.

1.@Target

@Target defines the scope of objects modified by Annotation. The specific modification scope is as follows:

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

Copy after login

2.@Retention

@Retention defines the length of time that the Annotation is retained, that is, it indicates the life cycle of the Annotation.

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

Copy after login

3.@Documented

@Documented defines Annotation, indicating that a certain type of annotation will be documented through javadoc and similar default tools.

If a type declaration is annotated with Documented, its annotation will become part of the annotated element's public API.

4.@Inherited

@Inherited defines Annotation, indicating that the annotation type is automatically inherited, that is, an annotation type modified with @Inherited is used A class, then this annotation will be used for subclasses of this class.

If you use an annotation type to annotate anything other than class, @Inherited will be invalid.
This meta-annotation only facilitates inheritance of annotations from the parent class; annotations for implemented interfaces are not valid.
When the Retention of the annotation annotated with the @Inherited annotation type is RetentionPolicy.RUNTIME, the reflection API enhances this inheritance. If we use java.lang.reflect to query annotation of an @Inherited annotation type, the reflective code inspection will start working: checking the class and its parent class until the specified annotation type is found, or the top level of the class inheritance structure is reached

The examples are as follows:

// 定义注解@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（若注释掉注解，返回异常）

Copy after login

Custom annotations

1. Class annotations

// 定义注解@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);
    }
}

Copy after login

2. Method annotation

// 定义注解@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);
    }

Copy after login

3. Parameter annotation

// 定义注解@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());
                }
            }
        }
    }
}

Copy after login

4. Variable annotations

// 定义注解@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);
    }
}

Copy after login

The above is the content of 09.Java Basics - Annotations. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!