LAGOU20 反射机制

最新推荐文章于 2022-02-09 19:47:30 发布

憨憨老婆伍

最新推荐文章于 2022-02-09 19:47:30 发布

阅读量172

点赞数

分类专栏： LAGOU课程文章标签： java

本文链接：https://blog.csdn.net/hwinte/article/details/106457689

版权

LAGOU课程专栏收录该内容

19 篇文章 0 订阅

订阅专栏

20.1 基本概念
通常情况下编写代码都是固定的，无论运行多少次执行的结果也是固定的，在某些特殊场合中编写代码是不确定要创建什么类型的对象，也不确定要调用什么样的方法，这些都希望通过运行时传递的参数来决定，该机制叫做动态编程技术，也就是反射机制。
通俗来说，反射机制就是用于动态创建对象并且动态调用方法的机制；
目前主流的框架底层都是采用反射机制实现的；
反射机制就是我们可以在运行阶段来决定创建什么样的对象以及调用什么样的方法的机制；
如：
Person p=new Person();=》表示声明Person类型的引用指向Person类型的对象；
p.show(); =》表示调用Person类中的成员方法show；
20.2 Class类
20.2.1 基本概念
java.lang.Class类的实例可以用于描述Java应用程序中的类和接口，也就是一种数据类型；
该类没有公共构造方法，该类的实例由Java虚拟机和类加载器自动构造完成，本质上就是加载到内存中的运行时类；
20.2.2 获取Class对象的方式
使用数据类型.class的方式可以获取对应类型的Class对象（掌握）；
使用引申/对象.getClass()的方式可以获取对应类型的Class对象；
使用包装类.TYPE的方式可以获取对应基本数据类型的Class对象；
使用Class.forName()的方式来获取参数指定类型的Class对象（掌握）；
使用类加载器ClassLoader的方式获取指定类型的Class对象；
20.3.3 常用的方法

方法声明	功能介绍
static Class<?> forName(String classNmae)	用于获取参数指定类型对应的Class对象并返回
T newInstance()	用于创建该Class对象所表示类的新实例

下面通过代码来展示一下获取class对象的5种方式：
这里的toString方法这样来解释：将对象转换为字符串，字符串的表示形式是字符串"class"或"interface"，后面跟一个空格，然后是getName返回的格式的类的完全限定名。如果此对象便是基本数据类型，则此方法返回基本类型的名称。如果此类对象表示void，则此方法返回"void"，如果此类对象表示数组类型，则此方法返回"class"，后跟getName。

package task20;

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {

        //1.使用数据类型.class的方式可以获取对应类型的Class对象
        Class c1 = String.class;
        System.out.println("c1="+c1); //自动调用toString方法 class java.lang.String
        c1=int.class;
        System.out.println("c1="+c1); //int
        c1=void.class;
        System.out.println("c1="+c1); //void

        System.out.println("--------------------------------");

        //2.使用对象.getClass()的方式获取对象的Class对象
        String str1=new String("hello");
        c1=str1.getClass();
        System.out.println("c1="+c1); //class java.lang.String

        Integer it1=20;
        c1=it1.getClass();
        System.out.println("c1="+c1); //class java.lang.Integer

        int num=5;
        //num.getClass(); Error:基本数据类型的变量不能调用方法

        System.out.println("--------------------------------");

        //3.使用包装类.TYPE的方式来获取对于基本数据类型的Class对象
        c1=Integer.TYPE;
        System.out.println("c1="+c1); //int

        c1=Integer.class;
        System.out.println("c1="+c1); //class java.lang.Integer

        System.out.println("--------------------------------");

        //4.调用Class类中的forName方法来获取对应的Class对象
        //c1=Class.forName("String");  //Error 要求写完整的名称：包名.类名
        c1=Class.forName("java.lang.String");
        System.out.println("c1="+c1);  //class java.lang.String

        c1=Class.forName("java.util.Date");
        System.out.println("c1="+c1);  //class java.util.Date

        //c1=Class.forName("int");
        //System.out.println("c1="c1);  //不能获取基本数据类型的Class对象

        System.out.println("--------------------------------");

        //5.使用类加载器的方式来获取Class对象
        ClassLoader classLoader=ClassTest.class.getClassLoader();
        System.out.println("classloader="+classLoader);
        c1=classLoader.loadClass("java.lang.String");
        System.out.println("c1="+c1); //class java.lang.String

    }
}

输出结果为：

c1=class java.lang.String
c1=int
c1=void
--------------------------------
c1=class java.lang.String
c1=class java.lang.Integer
--------------------------------
c1=int
c1=class java.lang.Integer
--------------------------------
c1=class java.lang.String
c1=class java.util.Date
--------------------------------
classloader=jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
c1=class java.lang.Integer

下面用代码来表示一下动态创建对象是什么含义：
先创建一个Person的类：

package task20;

public class Person {
    private String name="韩文韬";
    private int age=20;

    public Person(){
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后创建一个PersonConstructor的类：

package task20;
public class PersonConstructor {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //1.使用原始方式以无参方式构造Person类型的对象并打印
        Person p1 = new Person();
        System.out.println("无参方式创建的对象是："+p1); //null 0

        System.out.println("----------------------------------");
        //2.使用反射机制以无参形式构造Person类型的对象并打印
        Class c1=Class.forName("task20.Person");
        System.out.println("无参方式创建的对象是："+c1.newInstance()); //null 0
    }
}

打印出来的结果一模一样，但是为什么第二种比较复杂呢，第二种优势在于动态的创建对象；

package task20;
import java.util.Scanner;

public class PersonConstructor {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //1.使用原始方式以无参方式构造Person类型的对象并打印
        Person p1 = new Person();
        System.out.println("无参方式创建的对象是："+p1); //null 0

        System.out.println("----------------------------------");
        //2.使用反射机制以无参形式构造Person类型的对象并打印
        System.out.println("请输入要创建对象的类型");
        Scanner sc=new Scanner(System.in);
        String str1=sc.next();
        //Class c1=Class.forName("task20.Person");
        Class c1=Class.forName(str1);
        System.out.println("无参方式创建的对象是："+c1.newInstance()); //null 0
        sc.close();
    }
}

输出结果为：

无参方式创建的对象是：Person{name='韩文韬', age=20}
----------------------------------
请输入要创建对象的类型
task20.Person
无参方式创建的对象是：Person{name='韩文韬', age=20}

但是输入的方式也比较LOW，下面展示创建对象的类型可以从配置文件中读取：

package task20;


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class PersonConstructor {

    public static void main(String[] args) throws Exception {
        //1.使用原始方式以无参方式构造Person类型的对象并打印
        Person p1 = new Person();
        System.out.println("无参方式创建的对象是："+p1); //null 0

        System.out.println("----------------------------------");
        //2.使用反射机制以无参形式构造Person类型的对象并打印
        //创建对象的类型可以从键盘输入
        //System.out.println("请输入要创建对象的类型");
        //Scanner sc=new Scanner(System.in);
        //String str1=sc.next();
        //Class c1=Class.forName("task20.Person");
        //创建对象的类型可以从配置文件中读取
        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("d:/a.txt")));
        String str1=br.readLine();
        Class c1=Class.forName(str1);
        System.out.println("无参方式创建的对象是："+c1.newInstance()); //null 0
        //sc.close();
        br.close();
    }
}

a.txt中只要写入task20.Person，那么读取结果就与上述一致；
由于newInstance这个方法已经过时了，但是如果我们依然想用无参方式构造对象，那么我们就要用到Constructor类：
20.3 Constructor类
20.3.1 基本概念
java.lang.reflect.Constructor类主要用于描述获取到的构造方法信息；
20.3.2 Class类的常用方法

方法声明	功能介绍
Constructor< T> getConstructor(Class<?>)…parameterTypes)	用于获取此Class对象所表示类型中参数指定的公共构造方法
Constructor<?>[] getConstructors()	用于获取此Class对象所表示类型中所有的公共构造方法

20.3.3 Constructor类的常用方法

方法声明	功能介绍
T newInstance(Object…initargs)	使用此Constructor对象描述的构造方法来构造Class对象代表类型的新实例
int getModifiers()	获取方法的访问修饰符
String getName()	获取方法的名称
Class<?>[] getParameterTypes()	获取方法所有参数的类型

下面代码是运用Constructor类的实例：

package task20;


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.util.Scanner;

public class PersonConstructor {

    public static void main(String[] args) throws Exception {
        //1.使用原始方式以无参方式构造Person类型的对象并打印
        Person p1 = new Person();
        System.out.println("无参方式创建的对象是："+p1); //null 0

        System.out.println("----------------------------------");
        //2.使用反射机制以无参形式构造Person类型的对象并打印
        //创建对象的类型可以从键盘输入
        //System.out.println("请输入要创建对象的类型");
        //Scanner sc=new Scanner(System.in);
        //String str1=sc.next();
        //Class c1=Class.forName("task20.Person");
        //创建对象的类型可以从配置文件中读取
        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("d:/a.txt")));
        String str1=br.readLine();
        Class c1=Class.forName(str1);
        //System.out.println("无参方式创建的对象是："+c1.newInstance()); //null 0
        //获取Class对象对应类中的无参构造方法，也就是Person类中的无参构造方法
        Constructor constructor=c1.getConstructor();
        //使用获取到的无参构造方法来构造对应类型的对象，也就是Person类型的对象
        System.out.println("无参方式创建的对象是："+constructor.newInstance());
        //sc.close();
        br.close();

        System.out.println("----------------------------------");
        //3.使用原始方式以有参方式构造Person类型的对象并打印
        Person p2=new Person("zhangfei",30);
        System.out.println("有参方式构造的对象是："+p2); //zhangfei 30

        System.out.println("----------------------------------");
        //4.使用反射机制以有参方式构造对象Person类型的对象并打印
        //获取Class对象对应类中的有参构造方法，也就是Person类中的有参构造方法
        Constructor constructor1=c1.getConstructor(String.class,int.class);
        //使用获取到的有参构造方法来构造对应类型的对象，也就是Person类型的对象
        //newInstance方法中的实参是用于给有参构造方法的形参进行初始化的，也就是给name和age进行初始化
        System.out.println("有残方式构造的对象是："+constructor1.newInstance("zhangfei",30)); //zhangfei 30
    }
}

输出结果为：

无参方式创建的对象是：Person{name='韩文韬', age=20}
----------------------------------
无参方式创建的对象是：Person{name='韩文韬', age=20}
----------------------------------
有参方式构造的对象是：Person{name='zhangfei', age=30}
----------------------------------
有残方式构造的对象是：Person{name='zhangfei', age=30}

如果不知道类中有哪些构造方法怎么办呢？就需要用到getConstructor=》获取构造方法！

package task20;


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.util.Scanner;

public class PersonConstructor {

    public static void main(String[] args) throws Exception {
        //1.使用原始方式以无参方式构造Person类型的对象并打印
        Person p1 = new Person();
        System.out.println("无参方式创建的对象是："+p1); //null 0

        System.out.println("----------------------------------");
        //2.使用反射机制以无参形式构造Person类型的对象并打印
        //创建对象的类型可以从键盘输入
        //System.out.println("请输入要创建对象的类型");
        //Scanner sc=new Scanner(System.in);
        //String str1=sc.next();
        //Class c1=Class.forName("task20.Person");
        //创建对象的类型可以从配置文件中读取
        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("d:/a.txt")));
        String str1=br.readLine();
        Class c1=Class.forName(str1);
        //System.out.println("无参方式创建的对象是："+c1.newInstance()); //null 0
        //获取Class对象对应类中的无参构造方法，也就是Person类中的无参构造方法
        Constructor constructor=c1.getConstructor();
        //使用获取到的无参构造方法来构造对应类型的对象，也就是Person类型的对象
        System.out.println("无参方式创建的对象是："+constructor.newInstance());
        //sc.close();
        br.close();

        System.out.println("----------------------------------");
        //3.使用原始方式以有参方式构造Person类型的对象并打印
        Person p2=new Person("zhangfei",30);
        System.out.println("有参方式构造的对象是："+p2); //zhangfei 30

        System.out.println("----------------------------------");
        //4.使用反射机制以有参方式构造对象Person类型的对象并打印
        //获取Class对象对应类中的有参构造方法，也就是Person类中的有参构造方法
        Constructor constructor1=c1.getConstructor(String.class,int.class);
        //使用获取到的有参构造方法来构造对应类型的对象，也就是Person类型的对象
        //newInstance方法中的实参是用于给有参构造方法的形参进行初始化的，也就是给name和age进行初始化
        System.out.println("有残方式构造的对象是："+constructor1.newInstance("zhangfei",30)); //zhangfei 30

        System.out.println("----------------------------------");
        //5.使用反射机制获取Person类中所有的公共构造方法并打印
        Constructor[] constructors=c1.getConstructors();
        for(Constructor ct:constructors)
        {
            System.out.println("构造方法的访问修饰符是："+ct.getModifiers());
            System.out.println("构造方法的方法名称是："+c1.getName());
            Class[] parameterTypes=ct.getParameterTypes();
            System.out.print("构造方法的所有参数类型是：");
            for(Class cs:parameterTypes)
            {
                System.out.print(cs+" ");
            }
            System.out.println();
            System.out.println("----------------------------------");
        }
    }
}

输出结果为：

无参方式创建的对象是：Person{name='韩文韬', age=20}
----------------------------------
无参方式创建的对象是：Person{name='韩文韬', age=20}
----------------------------------
有参方式构造的对象是：Person{name='zhangfei', age=30}
----------------------------------
有残方式构造的对象是：Person{name='zhangfei', age=30}
----------------------------------
构造方法的访问修饰符是：1
构造方法的方法名称是：task20.Person
构造方法的所有参数类型是：
----------------------------------
构造方法的访问修饰符是：1
构造方法的方法名称是：task20.Person
构造方法的所有参数类型是：class java.lang.String int 
----------------------------------

20.4 Fileld类
20.4.1 基本概念
java.lang.reflect.Field主要用于描述获取到的单个成员变量信息；
20.4.2 Class类的常用方法

方法声明	功能介绍
Filed getDeclaredField(String name)	用于获取此Class对象所表示类中参数指定的单个成员变量信息
Field[] getDeclaredFileds()	用于获取此Class对象所表示类中所有成员变量信息

20.4.3 Field类的常用方法

方法声明	功能介绍
Object get(Object obj)	获取参数对象obj中此Field对象所表示成员变量的数值
void set(Object obj,Object value)	将参数对象obj中此Field对象表示成员变量的数值修改为参数value的数值
void setAcessible(boolean flag)	当实参传递true时，则反射对象在使用时应该取消java语言访问检查
int getModifiers()	获取成员变量的访问修饰符
Class<?> getType()	获取成员变量的数据类型
String getName()	获取成员变量的名称

下面的代码详细的阐述了Field类的使用：

package task20;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class PersonFiledTest {
    public static void main(String[] args) throws Exception {
        //1.使用原始方式构造对象以及获取成员变量的数值并打印
        //Person p1=new Person("zhangfei",30);
        //System.out.println("获取到的成员变量数值为："+p1.name);

        System.out.println("-----------------------------------");
        //2.使用反射机制来构造对象以及获取成员变量的数值并打印
        //2.1获取Class对象
        Class c1=Class.forName("task20.Person");
        //2.2根据Class对象获取对应的有参构造方法
        Constructor constructor=c1.getConstructor(String.class,int.class);
        //2.3使用有参构造方法来得到Person类型的对象
        Object object=constructor.newInstance("zhangfei",30);
        //2.4根据Class对象获取对应的成员变量信息
        Field field=c1.getDeclaredField("name");
        //设置java语言访问检查的取消 暴力反射
        field.setAccessible(true);
        //2.5使用Person类型的对象来获取成员变量的数值并打印
        //使用对象Object中名字为field成员变量的数值，也就是成员变量name的数值
        System.out.println("获取到的成员变量数值为："+field.get(object)); //zhangfei

        System.out.println("-----------------------------------");
        //3.使用原始方式修改指定对象中成员变量的数值后再次打印
        //p1.name="guanyu";
        //System.out.println("获取到的成员变量数值为："+p1.name); //关羽

        System.out.println("-----------------------------------");
        //4.使用反射机制修改指定对象中成员变量的数值后再次打印
        //表示修改对象object中名字为field成员变量的数值为guanyu，也就是成员变量name的数值为guanyu
        field.set(object,"guanyu");
        System.out.println("修改后的成员变量的数值为："+field.get(object));

        System.out.println("-----------------------------------");
        //5.获取Class对象对应类中所有的成员变量
        Field[] declaredFields=c1.getDeclaredFields();
        for(Field ft:declaredFields)
        {
            System.out.println("获取到的访问修饰符为："+ft.getModifiers());
            System.out.println("获取到的数据类型为："+ft.getType());
            System.out.println("获取到的成员变量名称是："+ft.getName());
            System.out.println("-----------------------------------");
        }
    }
}

输出结果为：

-----------------------------------
获取到的成员变量数值为：zhangfei
-----------------------------------
-----------------------------------
修改后的成员变量的数值为：guanyu
-----------------------------------
获取到的访问修饰符为：2
获取到的数据类型为：class java.lang.String
获取到的成员变量名称是：name
-----------------------------------
获取到的访问修饰符为：2
获取到的数据类型为：int
获取到的成员变量名称是：age
-----------------------------------

20.5 Method类
20.5.1 基本概念
java.lang.reflect.Method类主要用于描述获取到的单个成员方法信息。
20.5.2 Class类的常用方法

方法声明	功能介绍
Method getMethod(String name,Class< ?>…parameterTypes)	用于获取该Class对象表示类中名字为name参数为parameterTypes的指定公共成员方法
Method[] getMethods()	用于获取该Class对象表示类中所有公共成员方法

20.5.3 Method类的常用方法

方法声明	功能介绍
Object invoke(Object obj,Object…args)	使用对象obj来调用此Method对象所表示的成员方法，实参传递args
int getModifiers()	获取方法的访问修饰符
Class< ?> getReturnType()	获取方法的返回值类型
String getName()	获取方法的名称
Class<?>[] getParameterTypes()	获取方法所有参数的类型
Class<?> getExceptionTypes()	获取方法的异常信息

下面写个代码带大家使用一下：

package task20;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class PersonMethodTest {
    public static void main(String[] args) throws Exception{
        //1.使用原始方式构造对象并调用方法打印结果
        Person p1=new Person("zhangfei",30);
        System.out.println("调用方法的返回值是："+p1.getName()); //zhangfei

        System.out.println("---------------------------------------------");
        //2.使用反射机制构造对象并调用方法打印结果
        //2.1获取Class对象
        Class c1=Class.forName("task20.Person");
        //2.2根据Class对象来获取对应的有参构造方法
        Constructor constructor=c1.getConstructor(String.class,int.class);
        //2.3使用有参构造方法来构造对象并记录
        Object object=constructor.newInstance("zhangfei",30);
        //2.4根据Class对象来获取对应的成员方法
        Method method=c1.getMethod("getName");
        //2.5使用对象来调用成员方法进行打印
        //表示使用object对象调用method表示的方法，也就是调用getName()方法来获取姓名
        System.out.println("调用方法的返回值是："+method.invoke(object)); //zhangfei

        System.out.println("---------------------------------------------");
        //3.使用反射机制来获取类中所有成员方法并打印
        Method[] methods=c1.getMethods();
        for(Method mt:methods)
        {
            System.out.println("成员方法的修饰符是："+mt.getModifiers());
            System.out.println("成员方法的返回值类型是："+mt.getReturnType());
            System.out.println("成员方法的名称是："+mt.getName());
            System.out.println("成员方法形参列表的类型是：");
            Class<?>[] parameterTypes=mt.getParameterTypes();
            for (Class ct:parameterTypes) {
                System.out.print(ct+" ");
            }
            System.out.println("成员方法的异常列表是：");
            Class<?>[] exceptionTypes=mt.getExceptionTypes();
            for (Class ct:exceptionTypes) {
                System.out.print(ct+" ");
            }
            System.out.println();
            System.out.println("---------------------------------------------");
        }
    }
}

输出结果为：

调用方法的返回值是：zhangfei
---------------------------------------------
调用方法的返回值是：zhangfei
---------------------------------------------
成员方法的修饰符是：1
成员方法的返回值类型是：class java.lang.String
成员方法的名称是：toString
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：1
成员方法的返回值类型是：class java.lang.String
成员方法的名称是：getName
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：1
成员方法的返回值类型是：void
成员方法的名称是：setName
成员方法形参列表的类型是：
class java.lang.String 成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：1
成员方法的返回值类型是：void
成员方法的名称是：setAge
成员方法形参列表的类型是：
int 成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：1
成员方法的返回值类型是：int
成员方法的名称是：getAge
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：273
成员方法的返回值类型是：void
成员方法的名称是：wait
成员方法形参列表的类型是：
long 成员方法的异常列表是：
class java.lang.InterruptedException 
---------------------------------------------
成员方法的修饰符是：17
成员方法的返回值类型是：void
成员方法的名称是：wait
成员方法形参列表的类型是：
long int 成员方法的异常列表是：
class java.lang.InterruptedException 
---------------------------------------------
成员方法的修饰符是：17
成员方法的返回值类型是：void
成员方法的名称是：wait
成员方法形参列表的类型是：
成员方法的异常列表是：
class java.lang.InterruptedException 
---------------------------------------------
成员方法的修饰符是：1
成员方法的返回值类型是：boolean
成员方法的名称是：equals
成员方法形参列表的类型是：
class java.lang.Object 成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：257
成员方法的返回值类型是：int
成员方法的名称是：hashCode
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：273
成员方法的返回值类型是：class java.lang.Class
成员方法的名称是：getClass
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：273
成员方法的返回值类型是：void
成员方法的名称是：notify
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------
成员方法的修饰符是：273
成员方法的返回值类型是：void
成员方法的名称是：notifyAll
成员方法形参列表的类型是：
成员方法的异常列表是：

---------------------------------------------

20.6 获取其他结构信息

方法声明	功能介绍
Package getPackage()	获取所在包信息
Class<? super T> getSuperclass()	获取继承的父类信息
Class<?>[] getInterfaces	获取实现的所有接口
Annotation[] getAnnotations()	获取注解信息
Type[] getGenericInterfaces()	获取泛型信息

第一个类：Student类

package task20;

import java.io.Serializable;

@MyAnnotation
public class Student<T,E> extends Person implements Comparable<String>, Serializable {
    @Override
    public int compareTo(String o) {
        return 0;
    }}

第二个注释：

package task20;

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

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

第三个类：StudentTest

package task20;

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

public class StudentTest {
    public static void main(String[] args) throws Exception{
        //获取Student类型的Class对象
        Class c1=Class.forName("task20.Student");
        System.out.println("获取到的包信息是："+c1.getPackage());
        System.out.println("获取到的父类信息是："+c1.getSuperclass());

        System.out.println("---------------------------------------");
        System.out.println("获取到的接口信息是：");
        Class[] interfaces=c1.getInterfaces();
        for (Class ct:interfaces)
        {
            System.out.print(ct+" ");
        }
        System.out.println();

        System.out.println("---------------------------------------");
        System.out.println("获取到的注解信息是：");
        Annotation[] annotations=c1.getAnnotations();
        for (Annotation at:annotations)
        {
            System.out.print(at+" ");
        }
        System.out.println();

        System.out.println("---------------------------------------");
        System.out.println("获取到的泛型信息是：");
        Type[] genericInterfaces=c1.getGenericInterfaces();
        for (Type tt:genericInterfaces)
        {
            System.out.print(tt+" ");
        }
        System.out.println();
    }
}

输出结果为：

获取到的包信息是：package task20
获取到的父类信息是：class task20.Person
---------------------------------------
获取到的接口信息是：
interface java.lang.Comparable interface java.io.Serializable 
---------------------------------------
获取到的注解信息是：
@task20.MyAnnotation() 
---------------------------------------
获取到的泛型信息是：
java.lang.Comparable<java.lang.String> interface java.io.Serializable