反射、注解

发表于 更新于 分类于 ，
对反射、注解的简单介绍。

1. 反射

介绍的反射、动态代理、注解等知识点，在以后开发中极少用到，这些技术都是以后学习框架、或者做框架的底层源码。

接下来，我们就需要带着同学们认识一下什么是反射。其实API文档中对反射有详细的说明，我们去了解一下。在java.lang.reflect包中对反射的解释如下图所示

1
2
3
Package java.lang.reflect
-------------------------
提供用于获取有关类和对象的反射信息的类和接口。 Reflection允许以编程方式访问有关已加载类的字段，方法和构造函数的信息，以及使用反射字段，方法和构造函数在封装和安全限制内对其底层对应项进行操作。

翻译成人话就是：反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。

反射有啥用呢？其实反射是用来写框架用的。为了方便理解，举一个见过的例子：平时我们用IDEA开发程序时，用对象调用方法，IDEA会有代码提示，idea会将这个对象能调用的方法都给你列举出来，供你选择，如果下图所示

1702175913311

问题是IDEA怎么知道这个对象有这些方法可以调用呢? 原因是对象能调用的方法全都来自于类，IDEA通过反射技术就可以获取到类中有哪些方法，并且把方法的名称以提示框的形式显示出来，所以你能看到这些提示了。

那记事本写代码为什么没有提示呢? 因为技术本软件没有利用反射技术开发这种代码提示的功能！

认识了反射是什么之后，介绍一下反射具体学什么？

因为反射获取的是类的信息，那么反射的第一步首先获取到类才行。由于Java的设计原则是万物皆对象，获取到的类其实也是以对象的形式体现的，叫字节码对象，用Class类来表示。获取到字节码对象之后，再通过字节码对象就可以获取到类的组成成分了，这些组成成分其实也是对象，其中每一个成员变量用Field类的对象来表示、每一个成员方法用Method类的对象来表示，每一个构造器用Constructor类的对象来表示。

如下图所示：

反射学什么？

学习获取类的信息、操作它们

  1. 反射第一步：加载类，获取类的字节码：Class对象
  2. 获取类的构造器：Constructor对象
  3. 获取类的成员变量：Field对象
  4. 获取类的成员方法：Method对象

1.1 获取类的字节码

反射的第一步：是将字节码加载到内存，我们需要获取到字节码对象。

graph LR;
1.反射第一步:加载类,获取类的字节码:Class对象

A[Student.java] --> B[Student.class]
B --字节码文件加载到内存中--> C[内存中的Student.class]

比如有一个Student类，获取Student类的字节码代码有三种写法。不管用哪一种方式，获取到的字节码对象其实是同一个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test1Class{
    public static void main(String[] args){
        Class c1 = Student.class;
        System.out.println(c1.getName()); //获取全类名 com.itheima.Student
        System.out.println(c1.getSimpleName()); //获取简单类名 Student

        Class c2 = Class.forName("com.itheima.Student");
        System.out.println(c1 == c2); //true

        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c2 == c3); //true
    }
}

1.2 获取类的构造器

学习一下通过字节码对象获取构造器，并使用构造器创建对象。

获取构造器，需要用到Class类提供的几个方法，如下图所示：

方法 说明
Constructor<?>[] getConstructors() 获取全部构造器（只能获取public修饰的）
Constructor<?>[] getDeclaredConstructors() 获取全部构造器（只要存在就能拿到）
Constructor<T> getConstructor(Class<?>... parameterTypes) 获取某个构造器（只能获取public修饰的）
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取某个构造器（只要存在就能拿到）

这些方法的命名规律:

1
2
3
4
get:获取
Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的
Constructor: 构造方法的意思
后缀s: 表示可以获取多个，没有后缀s只能获取一个

话不多少，上代码。假设现在有一个Cat类，里面有几个构造方法，代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Cat{
    private String name;
    private int age;
    
    public Cat(){
        
    }
    
    private Cat(String name, int age){
        
    }
    
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
    1. 接下来，我们写一个测试方法，来测试获取类中所有的构造器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test2Constructor(){
    @Test
    public void testGetConstructors(){
        //1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        
        //2、获取类的全部构造器
        Constructor[] constructors = c.getDeclaredConstructors();
        //3、遍历数组中的每一个构造器对象。
        for(Constructor constructor: constructors){
            System.out.println(constructor.getName()+"---> 参数个数："+constructor.getParameterCount());
        }
    }
}

运行测试方法打印结果如下

1
2
com.itheima.reflect.Cat---> 参数个数：0
com.itheima.reflect.Cat---> 参数个数：2
    1. 刚才演示的是获取Cat类中所有的构造器，接下来，我们演示单个构造器试一试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Test2Constructor(){
    @Test
    public void testGetConstructor(){
        //1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        
        //2、获取类public修饰的空参数构造器
        Constructor constructor1 = c.getConstructor();
        System.out.println(constructor1.getName()+"---> 参数个数："+constructor1.getParameterCount());
        
        //3、获取private修饰的有两个参数的构造器，第一个参数String类型，第二个参数int类型
        Constructor constructor2 = 
            c.getDeclaredConstructor(String.class,int.class);
        
        System.out.println(constructor2.getName()+"---> 参数个数："+constructor2.getParameterCount());

    }
}

打印结果如下

1
2
com.itheima.reflect.Cat---> 参数个数：0
com.itheima.reflect.Cat---> 参数个数：2

1.3 反射获取构造器的作用

其实构造器的作用：初始化对象并返回。

这里我们需要用到如下的两个方法，注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。

Constructor提供的方法 说明
T newInstance(Object... initargs) 创建并返回此构造器对象表示的类的新实例，传入参数用于完成对象的初始化
public void setAccessible(boolean flag) 设置为true，表示禁止检查访问控制（使用暴力反射），也就是允许访问那些通常被限制访问的字段、方法或构造函数。

constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来

由于构造器是private修饰的，先需要调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。

实际上，调用setAccessible(true)方法表示取消对访问控制权限的检查，也就是允许访问那些通常被限制访问的字段、方法或构造函数。

具体来说，在Java中，当一个成员（字段、方法或构造函数）被声明为private、protected或默认访问修饰符时，通常只能在同一类内部进行访问。但是，通过使用反射并调用setAccessible(true)方法，可以绕过这些访问限制，从而在其他类中访问私有成员。

请注意，这种绕过访问控制的行为可能会违反面向对象编程的封装原则，并且可能导致代码的可维护性和可读性下降。因此，在正常情况下，应该避免滥用setAccessible(true)方法，只在必要的情况下使用。

代码如下：为了看到构造器真的执行， 故意在两个构造器中分别加了两个打印语句

1668579315586

代码的执行结果如下图所示：

1
2
3
4
5
6
com.itheima.reflect.Cat---> 参数个数：0
无参数构造器执行了~~
Cat{name='null', age=0}
com.itheima.reflect.Cat---> 参数个数：2
有参数构造器执行了~~
Cat{name='叮当猫', age=3}

1.4 反射获取成员变量&使用

其实套路是一样的，在Class类中提供了获取成员变量的方法，如下图所示。

方法 说明
public Field[] getFields() 获取类的全部成员变量（只能获取public修饰的）
public Field[] getDeclaredFields() 获取类的全部成员变量（只要存在就能拿到，无论访问修饰符如何）
public Field getField(String name) 获取类的某个成员变量（只能获取public修饰的）
public Field getDeclaredField(String name) 获取类的某个成员变量（只要存在就能拿到，无论访问修饰符如何）

这些方法的记忆规则，如下

1
2
3
4
get:获取
Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的
Field: 成员变量的意思
后缀s: 表示可以获取多个，没有后缀s只能获取一个
  • 假设有一个Cat类它有若干个成员变量，用Class类提供 的方法将成员变量的对象获取出来。

1668579681294

执行完上面的代码之后，我们可以看到控制台上打印输出了，每一个成员变量的名称和它的类型。

1668579804732

  • 获取到成员变量的对象之后该如何使用呢？

在Filed类中提供给给成员变量赋值和获取值的方法，如下图所示。

方法 参数 说明
void set(Object obj, Object value) obj: 要设置属性值的对象实例。value: 要设置的属性值 设置对象的属性值
Object get(Object obj) obj: 要获取属性值的对象实例 获取对象的属性值
public void setAccessible(boolean flag) flag: 是否取消访问控制检查 设置访问权限（通过暴力反射取消访问控制），若设置为 true，则取消检查，允许使用暴力反射修改对象的私有属性或调用私有方法。

再次强调一下设置值、获取值的方法时Filed类的需要用Filed类的对象来调用，而且不管是设置值、还是获取值，都需要依赖于该变量所属的对象。代码如下

1668580288930

执行代码，控制台会有如下的打印

1668580517173

1.5 反射获取成员方法

在Java中反射包中，每一个成员方法用Method对象来表示，通过Class类提供的方法可以获取类中的成员方法对象。如下下图所示

方法 说明
Method[] getMethods() 获取类的全部成员方法（只能获取 public 修饰的）
Method[] getDeclaredMethods() 获取类的全部成员方法（只要存在就能拿到）
Method getMethod(String name, Class<?>... parameterTypes) 获取类的某个成员方法（只能获取 public 修饰的）
Method getDeclaredMethod(String name, Class<?>... parameterTypes) 获取类的某个成员方法（只要存在就能拿到）

接下来我们还是用代码演示一下：假设有一个Cat类，在Cat类中红有若干个成员方法

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
public class Cat{
    private String name;
    private int age;
    
    public Cat(){
        System.out.println("空参数构造方法执行了");
    }
    
    private Cat(String name, int age){
        System.out.println("有参数构造方法执行了");
        this.name=name;
        this.age=age;
    }
    
    private void run(){
        System.out.println("(>^ω^<)喵跑得贼快~~");
    }
    
    public void eat(){
        System.out.println("(>^ω^<)喵爱吃猫粮~");
    }
    
    private String eat(String name){
        return "(>^ω^<)喵爱吃:"+name;
    }
    
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
     public int getAge(){
        return age;
    }
}

接下来，通过反射获取Cat类中所有的成员方法，每一个成员方法都是一个Method对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test3Method{
    public static void main(String[] args){
        //1、反射第一步：先获取到Class对象
        Class c = Cat.class;
        
        //2、获取类中的全部成员方法
        Method[] methods = c.getDecalaredMethods();
        
        //3、遍历这个数组中的每一个方法对象
        for(Method method : methods){
            System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());
        }
    }
}

执行上面的代码，运行结果如下图所示：打印输出每一个成员方法的名称、参数格式、返回值类型

1
2
3
4
5
6
7
getName-->0-->class java.lang.String
run-->0-->void
setName-->1-->void
getAge-->0-->int
eat-->1-->class java.lang.String
eat-->0-->void
setAge-->1-->void

也能获取单个指定的成员方法，如下图所示

1668581678388

获取到成员方法之后，有什么作用呢？

在Method类中提供了方法，可以将方法自己执行起来。

Method类中提供的方法 说明
public Object invoke(Object obj, Object... args) 触发某个对象的特定方法执行,obj: 要调用该方法的对象 args: 该方法的输入参数
public void setAccessible(boolean flag) 设置访问权限（通过暴力反射取消访问控制），若设置为 true，则取消检查，允许使用暴力反射修改对象的私有属性或调用私有方法。

把run()方法和eat(String name)方法执行起来。看分割线之下的代码

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
public class Test3Method{
    public static void main(String[] args){
        //1、反射第一步：先获取到Class对象
        Class c = Cat.class;
        
        //2、获取类中的全部成员方法
        Method[] methods = c.getDecalaredMethods();
        
        //3、遍历这个数组中的每一个方法对象
        for(Method method : methods){
            System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());
        }
        
        System.out.println("-----------------------");
        //4、获取private修饰的run方法，得到Method对象
        Method run = c.getDecalaredMethod("run");
        //执行run方法,在执行前需要取消权限检查
        Cat cat = new Cat();
        run.setAccessible(true);
        Object rs1 = run.invoke(cat);
        System.out.println(rs1)
        
        //5、获取private 修饰的eat(String name)方法，得到Method对象
        Method eat = c.getDeclaredMethod("eat",String.class);
        eat.setAccessible(true);
        Object rs2 = eat.invoke(cat,"鱼儿");
        System.out.println(rs2)
    }
}

打印结果如下图所示：run()方法执行后打印猫跑得贼快~~，返回null； eat()方法执行完，直接返回猫最爱吃:鱼儿

1
2
3
4
空参数构造方法执行了
(>^ω^<)喵跑得贼快~~
null
(>^ω^<)喵爱吃:鱼儿

1.6 反射的应用

反射的核心作用是用来获取类的各个组成部分并执行他们。一直说反射使用来写框架的，接下来，我们就写一个简易的框架。

需求是让我们写一个框架，能够将任意一个对象的属性名和属性值写到文件中去。不管这个对象有多少个属性，也不管这个对象的属性名是否相同。

分析一下该怎么做

1
2
3
4
5
6
7
8
9
1.先写好两个类，一个Student类和Teacher类
2.写一个ObjectFrame类代表框本架
  在ObjectFrame类中定义一个saveObject(Object obj)方法，用于将任意对象存到文件中去
  参数：Object obj: 就表示要存入文件中的对象
  
3.编写方法内部的代码，往文件中存储对象的属性名和属性值
  1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。
  2)接着就通过反射获取类的成员变量信息了（变量名、变量值）
  3)把变量名和变量值写到文件中去

写一个ObjectFrame表示自己设计的框架，代码如下图所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ObjectFrame{
    public static void saveObject(Object obj) throws Exception{
        PrintStream ps =
                new PrintStream(new FileOutputStream("D:\\Users\\cmy\\Desktop\\data.txt",true));
        //1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。
        //2)接着就通过反射获取类的成员变量信息了（变量名、变量值）
        Class c = obj.getClass(); //获取字节码

        ps.println("---------"+c.getSimpleName()+"---------");


        Field[] fields = c.getDeclaredFields(); //获取所有成员变量
        //3)把变量名和变量值写到文件中去
        for(Field field : fields){
            String name = field.getName();
            field.setAccessible(true); // 解除对私有成员的访问限制
            Object value = field.get(obj);
            ps.println(name + "=" + value);
        }
        ps.close();
    }
}

使用自己设计的框架，往文件中写入Student对象的信息和Teacher对象的信息。

先准备好Student类和Teacher类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Student{
    private String name;
    private int age;
    private char sex;
    private double height;
    private String hobby;

    public Student(String name, int age, char sex, double height, String hobby) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.hobby = hobby;
    }
}

1
2
3
4
5
6
7
8
9
public class Teacher {
    private String name;
    private double salary;

    public Teacher(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
}

创建一个测试类，在测试中类创建一个Student对象，创建一个Teacher对象，用ObjectFrame的方法把这两个对象所有的属性名和属性值写到文件中去。

1
2
3
4
5
6
7
8
9
10
public class Test5Frame{
    @Test
    public void save() throws Exception{
        Student s1 = new Student("黑马吴彦祖",45, '男', 185.3, "篮球，冰球，阅读");
        Teacher s2 = new Teacher("播妞",999.9);
        
        ObjectFrame.save(s1);
        ObjectFrame.save(s2);
    }
}

打开data.txt文件，内容如下图所示，就说明我们这个框架的功能已经实现了

1
2
3
4
5
6
7
8
9
---------Student---------
name=黑马吴彦祖
age=45
sex=男
height=185.3
hobby=篮球，冰球，阅读
---------Teacher---------
name=播妞
salary=999.9

2. 注解

2.1 认识注解&定义注解

先来认识一下什么是注解？

Java注解是代码中的特殊标记，比如@Override、@Test等，作用是让其他程序根据注解信息决定怎么执行该程序。

比如：Junit框架的@Test注解可以用在方法上，用来标记这个方法是测试方法，被@Test标记的方法能够被Junit框架执行。

再比如：@Override注解可以用在方法上，用来标记这个方法是重写方法，被@Override注解标记的方法能够被IDEA识别进行语法检查。

  • 注解不光可以用在方法上，还可以用在类上、变量上、构造器上等位置。

上面我们说的@Test注解、@Overide注解是别人定义好给我们用的，将来如果需要自己去开发框架，就需要我们自己定义注解。

接着我们学习自定义注解

自定义注解的格式如下图所示

1
2
3
public @interface 注解名称 {
    public 树形类型 属性名() default 默认值;
}

比如：现在我们自定义一个MyTest注解

1
2
3
4
5
public @interface MyTest{
    String aaa();
    boolean bbb() default true; //default true 表示默认值为true,使用时可以不赋值。
    String[] ccc();
}

定义好MyTest注解之后，我们可以使用MyTest注解在类上、方法上等位置做标记。注意使用注解时需要加@符号，如下

1
2
3
4
5
6
7
@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})
public class AnnotationTest1{
    @MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"})
    public void test1(){
        
    }
}

注意：当注解中只有一个属性且其名称为"value"时，可以省略"value"这个属性名，直接写属性值即可。比如现在重新定义一个MyTest2注解

1
2
3
4
public @interface MyTest2{
    String value(); //特殊属性
    int age() default 10;
}

定义好MyTest2注解后，再将@MyTest2标记在类上，此时value属性名可以省略，代码如下

1
2
3
4
5
6
7
8
@MyTest2("孙悟空") //等价于 @MyTest2(value="孙悟空")
@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})
public class AnnotationTest1{
    @MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"})
    public void test1(){
        
    }
}

到这里关于定义注解的格式、以及使用注解的格式就学习完了。

注解本质是什么呢？

想要搞清楚注解本质是什么东西，我们可以把注解的字节码进行反编译，使用XJad工具进行反编译。经过对MyTest1注解字节码反编译我们会发现：

1
2
3
4
1.MyTest1注解本质上是接口，每一个注解接口都继承子Annotation接口
2.MyTest1注解中的属性本质上是抽象方法
3.@MyTest1实际上是作为MyTest接口的实现类对象
4.@MyTest1(aaa="孙悟空",bbb=false,ccc={"Python","前端","Java"})里面的属性值，可以通过调用aaa()、bbb()、ccc()方法获取到。 【别着急，继续往下看，再解析注解时会用到】

2.2 元注解

什么是元注解？

元注解是修饰注解的注解。这句话虽然有一点饶，但是非常准确。我们看一个例子

1
2
3
4
5
6
7
@Retention(RetentionPolicy.RUNTIME) //@Retention注解是修饰Test注解的注解
@Target({ElementType.METHOD}) //@Target注解是修饰Test注解的注解

//这是自定义的Test注解
public @interface Test {

}

接下来分别看一下@Target注解和@Retention注解有什么作用，如下图所示

1
2
@Target是用来声明注解只能用在那些位置，比如：类上、方法上、成员变量上等
@Retetion是用来声明注解保留周期，比如：源代码时期、字节码时期、运行时期

@Target

@Target 作用：声明被修饰的注解只能在哪些位置使用

@Target(ElementType.TYPE)

  1. TYPE：类，接口
  2. FIELD：成员变量
  3. METHOD：成员方法
  4. PARAMETER：方法参数
  5. CONSTRUCTOR：构造器
  6. LOCAL_VARIABLE：局部变量

@Retention

@Retention 作用：指定注解的保留策略周期。

@Retention(RetentionPolicy.RUNTIME)

  1. SOURCE（源码级别）
    仅在源码阶段有效，不会被保留到编译后的字节码文件中。

  2. CLASS（默认值）
    在编译后的字节码文件中保留，但在运行阶段不起作用。

  3. RUNTIME（开发常用）
    在运行阶段一直保留有效。这是开发中常用的保留策略。

  • @Target元注解的使用：比如定义一个MyTest3注解，并添加@Target注解用来声明MyTest3的使用位置
1
2
3
4
@Target(ElementType.TYPE) //声明@MyTest3注解只能用在类上
public @interface MyTest3{
    
}

如果我们定义MyTest3注解时，使用@Target注解属性值写成下面样子

1
2
3
4
5
//声明@MyTest3注解只能用在类上和方法上
@Target({ElementType.TYPE,ElementType.METHOD})  
public @interface MyTest3{
    
}

到这里@Target元注解的使用就演示完毕了。

  • @Retetion元注解的使用：定义MyTest3注解时，给MyTest3注解添加@Retetion注解来声明MyTest3注解保留的时期
1
2
3
4
5
@Retetion是用来声明注解保留周期，比如：源代码时期、字节码时期、运行时期
  @Retetion(RetetionPloicy.SOURCE): 注解保留到源代码时期、字节码中就没有了
  @Retetion(RetetionPloicy.CLASS): 注解保留到字节码中、运行时注解就没有了
  @Retetion(RetetionPloicy.RUNTIME)：注解保留到运行时期
  【自己写代码时，比较常用的是保留到运行时期】
1
2
3
4
5
6
7
//声明@MyTest3注解只能用在类上和方法上
@Target({ElementType.TYPE,ElementType.METHOD})  
//控制使用了@MyTest3注解的代码中，@MyTest3保留到运行时期
@Retetion(RetetionPloicy.RUNTIME)
public @interface MyTest3{
    
}

2.3 解析注解

可以通过反射技术把类上、方法上、变量上的注解对象获取出来，然后通过调用方法就可以获取注解上的属性值了。把获取类上、方法上、变量上等位置注解及注解属性值的过程称为解析注解。

解析注解套路如下

1
2
3
4
1.如果注解在类上，先获取类的字节码对象，再获取类上的注解
2.如果注解在方法上，先获取方法对象，再获取方法上的注解
3.如果注解在成员变量上，先获取成员变量对象，再获取变量上的注解
总之：注解在谁身上，就先获取谁，再用谁获取谁身上的注解

  • Class、Method、Field,Constructor、都实现了AnnotatedElement接口，它们都拥有解析注解的能力。

    AnnotatedElement接口提供了解析注解的方法 说明 参数含义
    public Annotation[] getDeclaredAnnotations() 获取当前对象上面的注解 无
    public T getDeclaredAnnotation(Class<T> annotationClass) 获取指定的注解对象 annotationClass：要获取的注解类型的Class
    public boolean isAnnotationPresent(Class<Annotation> annotationClass) 判断当前对象上是否存在某个注解 annotationClass：要判断的注解类型的Class

解析来看一个案例，来演示解析注解的代码编写

按照需求要求一步一步完成

① 先定义一个MyTest4注解

1
2
3
4
5
6
7
8
9
//声明@MyTest4注解只能用在类上和方法上
@Target({ElementType.TYPE,ElementType.METHOD})  
//控制使用了@MyTest4注解的代码中，@MyTest4保留到运行时期
@Retetion(RetetionPloicy.RUNTIME)
public @interface MyTest4{
    String value();
    double aaa() default 100;
    String[] bbb();
}

② 定义有一个类Demo

1
2
3
4
5
6
7
@MyTest4(value="蜘蛛侠",aaa=99.9, bbb={"至尊宝","黑马"})
public class Demo{
    @MyTest4(value="孙悟空",aaa=199.9, bbb={"紫霞","牛夫人"})
    public void test1(){
        
    }
}

③ 写一个测试类AnnotationTest3解析Demo类上的MyTest4注解

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
public class AnnotationTest3{
    @Test
    public void parseClass(){
        //1.先获取Class对象
        Class c = Demo.class;
        
        //2.解析Demo类上的注解
        if(c.isAnnotationPresent(MyTest4.class)){
            //获取类上的MyTest4注解
            MyTest4 myTest4 = (MyTest4)c.getDeclaredAnnotation(MyTest4.class);
            //获取MyTests4注解的属性值
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(myTest4.bbb());
        }
    }
    
    @Test
    public void parseMethods(){
        //1.先获取Class对象
        Class c = Demo.class;
        
        //2.解析Demo类中test1方法上的注解MyTest4注解
        Method m = c.getDeclaredMethod("test1");
        if(m.isAnnotationPresent(MyTest4.class)){
            //获取方法上的MyTest4注解
            MyTest4 myTest4 = (MyTest4)m.getDeclaredAnnotation(MyTest4.class);
            //获取MyTests4注解的属性值
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(myTest4.bbb());
        }
    }
}