java注解（Annotation）

最新推荐文章于 2023-10-22 04:54:38 发布

yangyuessw

最新推荐文章于 2023-10-22 04:54:38 发布

阅读量126

点赞数 1

本文链接：https://blog.csdn.net/yangyuessw/article/details/119407793

版权

Java 注解（Annotation）

Java 中的 类、方法、变量、参数和包 等都可以被标注。和 Javadoc 不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容。当然它也支持自定义 Java 标注。

java内置的注解

Java 内置了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。

java.lang 包下：

@Override  		       检查该方法是否是重写方法。如果发现其父类，或者是实现的接口中并没有该方法时，会报编译错误。
@Deprecated  		   标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings      指示编译器去忽略注解中声明的警告。

java.lang.annotation 包下有四个元注解：作用于注解的注解

@Retention （RetentionPolicy.RUNTIME） 	保留机制，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
@Documented 							标记这些注解是否包含在用户文档中。
@Target （ElementType.type）			标记这个注解应该作用于哪种 Java 成员。
@Inherited      						被这个注解标注的注解具有继承性

从 Java 7 开始，额外添加了 3 个注解:

@SafeVarargs - 				Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
@FunctionalInterface		Java 8 开始支持，标识一个匿名函数 函数式接口。
@Repeatable - 				Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

JDK注解三个重要的主干类

java.lang.annotation 包下有个接口 Annotation，所有注解都是该接口的实现类。
在这里插入图片描述

从中，我们可以看出：

(1) 1 个 Annotation 和 1 个 RetentionPolicy （保留机制）关联。 即每1个Annotation对象，都会有唯一的RetentionPolicy属性。

(2) 1 个 Annotation 和 1~n 个 ElementType（作用范围） 关联。可以理解为：对于每 1 个 Annotation 对象，可以有若干个 ElementType 属性。

(3) Annotation 有许多实现类，包括：Deprecated, Documented, Inherited, Override 等等。
	Annotation 的每一个实现类，都 "和 1 个 RetentionPolicy  和多个 ElementType 关联"。

Annotation 接口： 所有注解根接口

package java.lang.annotation;
public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}

ElementType 枚举类： 指定注解作用范围

package java.lang.annotation;
public enum ElementType {
    TYPE,               /* 类、接口（包括注释类型）或枚举声明  */

    FIELD,              /* 字段声明（包括枚举常量）  */

    METHOD,             /* 方法声明  */

    PARAMETER,          /* 参数声明  */

    CONSTRUCTOR,        /* 构造方法声明  */

    LOCAL_VARIABLE,     /* 局部变量声明  */

    ANNOTATION_TYPE,    /* 注释类型声明  */

    PACKAGE             /* 包声明  */
}

RetentionPolicy 枚举类： 指定注解保留机制

package java.lang.annotation;
public enum RetentionPolicy {
    SOURCE,            /* Annotation信息仅存在于编译器处理期间，.class文件没有该Annotation信息了  */

    CLASS,             /* 编译器将Annotation存储于类对应的.class文件中。默认行为  */

    RUNTIME            /* 编译器将Annotation存储于class文件中，并且可由JVM读入 */
}

a) RetentionPolicy 为 SOURCE，则意味着：Annotation 仅存在于编译器处理期间，编译器处理完之后，该 Annotation 就没用了。 
   例如，" @Override" 这个 Annotation。当它修饰一个方法的时候，表明该方法重写父类的方法；并且在编译期间会进行语法检查！
   编译器处理完后，"@Override" 信息不保留于 .class 中。
   
b) RetentionPolicy 为 CLASS，则意味着：编译器将 Annotation 存储于类对应的 .class 文件中，它是 Annotation 的默认行为。

c) RetentionPolicy 为 RUNTIME，则意味着：编译器将 Annotation 存储于 class 文件中，并且可由JVM读入。

@Inherited注解分析

@Inherited 的含义是，它所标注的Annotation将具有继承性。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)		//作用范围为注解，标志该注解具有继承性
public @interface Inherited {
}

注解继承性的解释：

假设，我们定义了某个注解，名称是 MyAnnotation，并且用 @Inherited  标注MyAnnotation 表明自定义注解具有继承性。
现在，某个父类 Base 被 MyAnnotation标注了，而子类 Sub 继承了父类 Base，由于 MyAnnotation 是 @Inherited的(具有继承性)，
所以，子类 Sub 相当于也被注解 MyAnnotation标注了，具有 MyAnnotation注解属性。

自定义注解 Inheritable，并声明其有继承性

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Inheritable
{
}

定义父类并用 @Inheritable标注

@Inheritable
class InheritableFather
{
    public InheritableFather() {
        // InheritableBase是否具有 Inheritable Annotation
        System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
    }
}

定义子类

public class InheritableSon extends InheritableFather
{
    public InheritableSon() {
        // 调用父类的构造函数，父类有 @Inheritable 注解属性
        super();    
        // 查看子类是否有 @Inheritable 注解属性
        System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
    }
   
    public static void main(String[] args)
    {
        InheritableSon is = new InheritableSon();
    }
}

控制台输出为：说明被 @Inherited标注的注解局继承性。

InheritableFather:true
InheritableSon:true

java 自定义注解：

作用范围 @Target 默认全部，即所有地方，保留机制 @Retention 默认为 RetentionPolicy.RUNTIME

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
}

定义注解用 @interface: 即该注解为 Annotation接口实现类

用 @interface定义注解，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他的注解或接口。

在反射中使用 Annotation：

反射可以通过类名、方法名、形参名获取方法Method：

Class<Person> personClass = Person.class;
Method empty = personClass.getMethod("empty");											//形参为空
Method somebody = personClass.getMethod("somebody", String.class, int.class);			//形参不为空

反射可以通过Method、Class、Field、Constructor、Pararmeter等获取其上的注解信息：

somebody .isAnnotationPresent(MyAnnotation.class)            		       // 判断 somebody 方法上是否存在某类注解
MyAnnotation annotation = somebody .getAnnotation(MyAnnotation.class);     // 获取 MyAnnotation类注解
Annotation[] annotations = somebody .getAnnotations();					   //获取方法上所有注解

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation{
    String[] values() default "unknown";
}


class Person {

    @Deprecated
    @MyAnnotation
    public void empty(){
        System.out.println("反射调用empty方法");
    }


    @MyAnnotation(values={"girl","boy"})
    public void somebody(String name, int age){
        System.out.println("反射调用somebody方法 : "+name+", "+age);
    }
}

public class AnnotationTest {

    public static void main(String[] args) throws Exception {

        Person person = new Person();

        Class<Person> personClass = Person.class;


        //反射获取两个方法，通过方法名和方法形参class
        Method empty = personClass.getMethod("empty");
        Method somebody = personClass.getMethod("somebody", String.class, int.class);

		//反射调用两个方法，并获方法上的注解信息
        empty.invoke(person);
        iteratorAnnotations(empty);

        System.out.println();

        somebody.invoke(person,"yangyue",18);
        iteratorAnnotations(somebody);
    }

    public static void iteratorAnnotations(Method method) {

        //查看方法上是否有自定义 MyAnnotation注解，如果有，打印出自定义注解的 values属性
        if(method.isAnnotationPresent(MyAnnotation.class)){
            MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
            String[] values = annotation.values();
            for (String value : values) {
                System.out.println("自定义注解的values属性值： "+value);
            }
        }

        //找出该方法上的所有 注解
        Annotation[] annotations = method.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

    }
}

执行结果如下：

反射调用empty方法
自定义注解的values属性值： unknown
@java.lang.Deprecated()
@com.kuang.dao.MyAnnotation(values=[unknown])

反射调用somebody方法 : yangyue, 18
自定义注解的values属性值： girl
自定义注解的values属性值： boy
@com.kuang.dao.MyAnnotation(values=[girl, boy])

yangyuessw

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java注解（Annotation）

Java 注解（Annotation）Java 中的类、方法、变量、参数和包等都可以被标注。和 Javadoc 不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容。当然它也支持自定义 Java 标注。java内置的注解Java 内置了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。java.lang 包下：@Over
复制链接

扫一扫