Java高级编程—注解

1.注解的概述

Annotation（注解）是 JDK 5.0时加的新特性。 从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是 Annotation(注解) 。
Annotation 其实就是代码里的特殊标记 , 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在 Annotation 的 “name=value” 对中。
在JavaSE中，注解的使用目的比较简单，例如标记过时的功能， 忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如 用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以 上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的 Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上 可以说：框架 = 注解 + 反射 + 设计模式。

2.常见的Annotation示例

使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成 一个修饰符使用。用于修饰它支持的程序元素。

2.1 生成文档相关的注解

其中： 1. @param @return 和 @exception 这三个标记都是只用于方法的。
2. @param和@exception可以并列多个。
下面给出一个实例体会一下：

package com.annotation.javadoc;
    /**
    * @author shkstart
    * @version 1.0
    * @see Math.java
    */
    public class JavadocTest {
    /**
    * 程序的主方法，程序的入口
    * @param args String[] 命令行参数
    */
    public static void main(String[] args) {
    }
    /**
    * 求圆面积的方法
    * @param radius double 半径值
    * @return double 圆的面积
    */
    public static double getArea(double radius){
    return Math.PI * radius * radius;
    }
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在上述的例子当中，除了表格中的 @since 和 @exception 两个没有用到外，其余的生成文档相关的注解都已经使用过了。

2.2 在编译时进行格式检查的注解

在这一部分中，JDK内置了三个基本的注解，分别为： @Override 、@Deprecated 和 @SuppressWarnings 。

下面分别给出它们的使用：

1. @Override的使用

class Person{
    private String name;
    private int id;

    public Person() {
    }

    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void walk(){
        System.out.println("人走路");
    }

    public void eat(){
        System.out.println("人吃饭");
    }

}

class Student extends Person{

    @Override        //在编译时检查一下这个walk方法是不是重写父类的（如果不是，就会给出报错的提示）
    public void walk() {
        System.out.println("学生走路");
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在上述代码块中，我们先是定义了一个Person类，在声明了两个属性，提供了构造器后提供了两个方法walk()和eat()； 接着定义了一个Student类去继承Person类，并重写了walk方法。
下面我们给出测试：

public class AnnotationTest {
    public static void main(String[] args) {
        Person p = new Student();
        p.walk();
    }
    
}
1
2
3
4
5
6
7

测试结果如下：

使用 @Override 的好处是它会在编译时检查一下这个walk方法是不是重写父类的，如果重写walk方法写的是对的，那么不使用 @Override 也没有什么影响，编译器只是不会帮你检查了，但效果是一样的。如果写错了，它就会给出报错的提示。比如walk拼写错误，把字母l写成了数字1，那么在编译时就过不去。如下图所示：

2.@Deprecated的使用
加上了@Deprecated 修饰的结构表示时已经过时了，但是过时了的东西还是可以用的，只是不建议使用。

public class AnnotationTest {
    public static void main(String[] args) {
        
//      这个构造器就是已经过时了，但是过时了的东西还是可以用的
        Date date = new Date(2020, 10, 11);
        System.out.println(date);
    }
}
1
2
3
4
5
6
7
8

上述代码块中的Date类的构造器就已经过时了，API文档的解释如下：

3.@SuppressWarnings的使用
@SuppressWarnings的作用是抑制编译器的警告，比如我们在程序中定义了一个变量，但是目前还没有使用过，此时编译器就会报一个 ‘unused’ 的警告。这个在eclipse中表现的更加明显。如下所示：

在main方法中我们定义了一个整型变量num，但未使用，此时就会在函数的左边出现黄色的警告。

在这个变量上添加 @SuppressWarnings(“unused”) 的注解后，左边的警告就消失了。
需要注意的是：@SuppressWarnings() 的参数部分可以写多个值，也就是可以抑制多个警告。这是因为它的成员变量是一个字符串数组。API 如下图所示：

2.3 跟踪代码依赖性，实现替代配置文件功能的注解

举出如下的两个例子来说明一下：
Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署。

public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException { }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException {
    doGet(request, response);
    }
}
1
2
3
4
5
6
7
8
9

要想在客户端输入/login时执行这个Servlet 内的业务逻辑，需要写配置文件作映射，如下所示：

<servlet>
<servlet-name>LoginServletservlet-name>
<servlet-class>com.servlet.LoginServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>LoginServletservlet-name>
<url-pattern>/loginurl-pattern>
servlet-mapping>
1
2
3
4
5
6
7
8

而有了注解后只需为该Servlet添加一个@WebServlet即可：

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException { }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException {
    doGet(request, response);
    }
}
1
2
3
4
5
6
7
8
9
10

Spring框架关于事务的管理：
在原来需要使用配置文件指明事务的管理情况，现在可以把这些信息体现为注解，不需要再去写xml文件了。

@Transactional(propagation=Propagation.REQUIRES_NEW,
    isolation=Isolation.READ_COMMITTED,readOnly=false,timeout=3)
    public void buyBook(String username, String isbn) {
    //1.查询书的单价
    int price = bookShopDao.findBookPriceByIsbn(isbn);
    //2. 更新库存
    bookShopDao.updateBookStock(isbn);
    //3. 更新用户的余额
    bookShopDao.updateUserAccount(username, price);
}
1
2
3
4
5
6
7
8
9
10

<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
<tx:attributes>

<tx:method name="buyBook" propagation="REQUIRES_NEW"
isolation="READ_COMMITTED" read-only="false" timeout="3" />
tx:attributes>
tx:advice>
1
2
3
4
5
6
7
8

3.自定义Annotation

注解也可以自定义，就像自定义类、接口、异常一样。如果现有的注解不能够满足我们的需求，那么我们也可以自定义注解。
如何自定义注解？
我们仿照 SuppressWarnings 自定义一个注解，先来看一下 SuppressWarnings 的结构：

package java.lang;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;

/**
 * Indicates that the named compiler warnings should be suppressed in the
 * annotated element (and in all program elements contained in the annotated
 * element).  Note that the set of warnings suppressed in a given element is
 * a superset of the warnings suppressed in all containing elements.  For
 * example, if you annotate a class to suppress one warning and annotate a
 * method to suppress another, both warnings will be suppressed in the method.
 *
 * 
As a matter of style, programmers should always use this annotation
 * on the most deeply nested element where it is effective.  If you want to
 * suppress a warning in a particular method, you should annotate that
 * method rather than its class.
 *
 * @author Josh Bloch
 * @since 1.5
 * @jls 4.8 Raw Types
 * @jls 4.12.2 Variables of Reference Type
 * @jls 5.1.9 Unchecked Conversion
 * @jls 5.5.2 Checked Casts and Unchecked Casts
 * @jls 9.6.3.5 @SuppressWarnings
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    /**
     * The set of warnings that are to be suppressed by the compiler in the
     * annotated element.  Duplicate names are permitted.  The second and
     * successive occurrences of a name are ignored.  The presence of
     * unrecognized warning names is not an error: Compilers must
     * ignore any warning names they do not recognize.  They are, however,
     * free to emit a warning if an annotation contains an unrecognized
     * warning name.
     *
     * 
 The string {@code "unchecked"} is used to suppress
     * unchecked warnings. Compiler vendors should document the
     * additional warning names they support in conjunction with this
     * annotation type. They are encouraged to cooperate to ensure
     * that the same names work across multiple compilers.
     * @return the set of warnings to be suppressed
     */
    String[] value();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

从 Annotation 的定义中可以看出：
1.注解声明为 @interface ，即自定义注解需要使用这个关键字。
2.自定义注解自动继承了 java.lang.annotation.Annotation 接口。
3. Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、 以上所有类型的数组。
（在 SuppressWarnings 中声明的是一个String类型的数组，因为该注解有多个成员变量）
4. 可以在定义 Annotation 的成员变量时为其指定初始值, 指定成员变量的初始值使用 default 关键字。
5. 如果只有一个参数成员，建议使用参数名为 value。
6. 如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认 值。格式是“参数名 = 参数值” ，如果只有一个参数成员，且名称为value， 可以省略“value=”。
7.如果自定义的注解没有成员，表明是一个标识作用。可以类比一下 io 流中的Serializable 接口（一个没有抽象方法的接口，只是起到一个标志的作用）。比如：@override这个注解里就是没有成员的。
下面我们自定义一个名为 MyAnnotation 的注解：

/*
* 注：@interface 和 interface 没有任何的关系
* */
public @interface MyAnnotation {

    String value();    //若有多个成员变量时可以指定成数组

}
1
2
3
4
5
6
7
8

然后我们就可以使用这个注解了，这里我们把它添加到Person类上。如下所示：

@MyAnnotation(value = "kaixuan")   
class Person{
    private String name;
    private int id;

    public Person() {
    }
    
    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void walk(){
        System.out.println("人走路");
    }

    public void eat(){
        System.out.println("人吃饭");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

有几点需要注意：
1.value 是MyAnnotation 的成员变量的值，必须要给它指定了，不然会value丢失的错。

2.如果不想在使用的地方指定，也可以在声明 MyAnnotation 时为 value 指定一个默认的值。

public @interface MyAnnotation {
    
    String value() default "dabing";    //若有多个成员变量时可以指定成数组
}
1
2
3
4

当然默认指定的优先级一定是低于添加注解时指定的value值的。
3.自定义注解必须配上注解的信息处理流程（使用反射）才有意义。

4.JDK中的元注解

JDK 的元注解用于修饰其他 Annotation 定义。也就是说：元注解是对现有的注解进行解释说明的注解。
以"元数据"的解读来类比一下，比如现在有一个字符串类型的数据如下：

String name = "kaixuan";
1

显然，这里的数据是"kaixuan"，是程序中要使用到的数据。而其余两部分“String”和“name”是用来修饰这个数据的，“String”指明了这个数据的类型是字符串；“name”是给这个数据起了个名字。所以这两个修饰"kaixuan"的数据String和name 就被称为＂元数据＂。理解了元数据，那么元注解也就不难理解了吧。
JDK5.0提供了4个标准的meta-annotation类型，分别是：Retention、Target、Documented 和 Inherited。各自的作用如下表所示：

| Retention | 指定所修饰的Annotation的生命周期：SOURCE / CLASS(默认行为) / RUNTIME
(只有声明为RUNTIME生命周期的注解，才能通过反射获取。) |
| — | — |
| Target | 用于指定被修饰的Annotation能用于修饰哪些程序元素 |
| Documented | 用于指定被该元 Annotation 修饰的注解在被javadoc解析时，保留下来。 |
| Inherited | 被它修饰的Annotation将具有继承性。如果某个类使用了@Inherited修饰的注解，则其子类将自动具有该注解。 |

4.1 Retention

该注解只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 的生命周期。
如何实现指定Annotation 生命周期？
@Rentention 包含一个 RetentionPolicy 类型的成员变量, 而这个RetentionPolicy本身又是枚举类型的，其中包含三个值：SOURCE，CLASS, RUNTIME。
Retention注解源码如下：

RetentionPolicy 枚举类如下：
下面说一下这三个值的作用：

所以只有声明为 RUNTIME 生命周期的注解，才能通过反射获取。
下面我们给刚才自定义的注解MyAnnotation 加上Retention，并把内部的RetentionPolicy 成员的值指定为 RUNTIME 来做一下测试：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "dabing";    //若有多个成员变量时可以指定成数组

}
1
2
3
4
5
6
7
8
9

这样设计后就可以在运行时获取到这个注解信息了。把MyAnnotation添加到Person类上，由于MyAnnotation里已经给出了默认的value值就不再指定。

@MyAnnotation()                                 
class Person{
    private String name;
    private int id;

    public Person() {
    }

    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void walk(){
        System.out.println("人走路");
    }

    public void eat(){
        System.out.println("人吃饭");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

然后我们通过反射来获取一下Person类上的注解信息，给出如下的测试：

@Test
public void test1() {
    Class clazz = Person.class;
    Annotation[] annotations = clazz.getAnnotations();
    for (Annotation a : annotations) {
        System.out.println(a);
    }
}
1
2
3
4
5
6
7
8

测试结果如下：

4.2 Target

用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。
查看一下Target的源码：

package java.lang.annotation;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}
1
2
3
4
5
6
7
8
9
10
11
12
13

可以看到，它里面的value是一个ElementType类型的数组，深入查看 value 数组如下：

package java.lang.annotation;

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

可以看到，这也是一个枚举类，内部定义了十个常量，分别代表什么注释中已经写的很清楚了。
下面再看一下 Target 对 SuppressWarnings 的修饰：

很显然，Target 指定了SuppressWarnings 可以作用的六种类型，也就是说只有在这几类结构上面是可以添加 SuppressWarnings 注解的，而其他的结构不行。我们也可以为刚才自定义的MyAnnotation添加元注解Target，指明MyAnnotation 可以修饰哪些结构。

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "dabing";    //若有多个成员变量时可以指定成数组

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

自定义注解通常都会指明两个元注解：Retentino、Target。

4.3 Documented & Inherited

Documented : 用于指定被该元 Annotation 修饰的注解在被javadoc解析时，保留下来。默认情况下，javadoc是不包括注解的。（ 定义为Documented的注解必须设置Retention值为RUNTIME。 ）
Inherited ：它修饰的Annotation将具有继承性。如果某个类使用了@Inherited 修饰的注解，则其子类将自动具有该注解。
下面给出Inherited注解的测试：
首先为MyAnnotation注解添加Inherited 元注解：

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Inherited
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "dabing";    //若有多个成员变量时可以指定成数组

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在Person类上使用MyAnnotation注解，并指定其中的value值为"kaixuan"，Student为Person的子类，不添加注解：

import org.junit.Test;
import java.lang.annotation.Annotation;

@MyAnnotation("kaixuan")                                    //value是MyAnnotation的成员变量的值，必须要给它指定了，不然会报错。也可以在声明注解时给出value的默认值
class Person{
    private String name;
    private int id;

    public Person() {
    }

    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void walk(){
        System.out.println("人走路");
    }

    public void eat(){
        System.out.println("人吃饭");
    }

}

interface Info{
    void show();
}

class Student extends Person implements Info{

    @Override        //在编译时检查一下这个walk方法是不是重写父类的（如果不是，就会给出报错的提示）
    public void walk() {
        System.out.println("学生走路");
    }

    @Override      //实现接口中的抽象方法
    public void show() {

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

给出测试程序，验证 Student 类上是否有MyAnnotation注解：

@Test
    public void testGetAnnotation(){
        Class clazz = Student.class;
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation a : annotations){
            System.out.println(a);
        }
    }
1
2
3
4
5
6
7
8

测试结果如下：

可以看到，Student类上的MyAnnotation和其父类中的是一样的。

5. JDK8中注解的新特性

Java 8 对注解处理提供了两点改进：可重复的注解及可用于类型的注解。

5.1 可重复注解

如果希望一个注解可以在一个结构（类、接口、属性、方法…）上同时使用多次，那么这个注解就被称为“重复注解”。
比如说现在想要把我们自定义的 MyAnnotation 注解在Person类上使用两次，如下所示：

@MyAnnotation("kaixuan")
@MyAnnotation("runze")
class Person{
    private String name;
    private int id;

    public Person() {
    }

    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void walk(){
        System.out.println("人走路");
    }

    public void eat(){
        System.out.println("人吃饭");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

但是这个时候肯定是会报错的，如下图所示：

这是因为MyAnnotation 只能赋一次值，使用之后就没了不能再用了。要想实现这个功能，只能再声明一个value值为 MyAnnotation类型的数组 的新的注解，使用这个注解完成这个功能。比如声明为MyAnnotations，设计如下：

public @interface MyAnnotations {
    MyAnnotation[] value();
}
1
2
3

接着在Person类上添加MyAnnotations 注解，形式如下：

上述的做法是jdk 8之前的写法，那么在jdk 8 引入了可重复注解之后，可以怎么实现呢？
首先我们需要为 MyAnnotation 注解添加一个元注解 Repeatable，并传入一个Class实例，也就是一个运行时类，这里我们传入MyAnnotations.class。Repeatable注解的源码如下：

可见，Repeatable注解的value值类型为Class的实例。
接着我们把MyAnnotations 和 MyAnnotation 的生命周期Retention、所作用的结构Target 以及Inherited都保持一致。
最终的MyAnnotation设计如下：

import java.lang.annotation.*;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

//在MyAnnotation中使用MyAnnotations，所以要求MyAnnotations的生命周期不能小于MyAnnotation，避免出现当要使用；
//的时候，MyAnnotations不可用；而作用的对象也是一样的道理，将它们的作用对象保持一致即可。
@Inherited
@Repeatable(MyAnnotations.class)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "dabing";    //若有多个成员变量时可以指定成数组
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

MyAnnotations设计如下：

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
    MyAnnotation[] value();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这个时候就可以实现在Person类上多次使用MyAnnotation了。

可以看到，写成最开始的需求也不会报错了。

5.2 类型注解

JDK 8之后，关于元注解@Target的参数类型ElementType枚举值多了两个： TYPE_PARAMETER,TYPE_USE。
在Java 8之前，注解只能是在声明的地方所使用，Java8开始，注解可以应用 在任何地方。

下面给出测试：

//使用注解修饰泛型的类型
class Generic<@MyAnnotation T>{
    public void show()  throws @MyAnnotation RuntimeException {
        //使用注解修饰别的任何语句
        ArrayList<@MyAnnotation String> list = new ArrayList<>();

        int num = (@MyAnnotation int) 10L;
    }
}
1
2
3
4
5
6
7
8
9

同时需要为MyAnnotation注解的Target元注解添加TYPE_PARAMETER和TYPE_USE。

@Inherited
@Repeatable(MyAnnotations.class)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, TYPE_PARAMETER,TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "dabing";    //若有多个成员变量时可以指定成数组
}
1
2
3
4
5
6
7