01、Java反射机制概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
image.png

1、动态语言

是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。

2、静态语言

与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

  • Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！
  • Java反射机制提供的功能
    • 在运行时判断任意一个对象所属的类
    • 在运行时构造任意一个类的对象
    • 在运行时判断任意一个类所具有的成员变量和方法
    • 在运行时获取泛型信息
    • 在运行时调用任意一个对象的成员变量和方法
    • 在运行时处理注解
    • 生成动态代理
  • 反射相关的主要API
    • java.lang.Class:代表一个类
    • java.lang.reflect.Method:代表类的方法
    • java.lang.reflect.Field:代表类的成员变量
    • java.lang.reflect.Constructor:代表类的构造器

测试类

  1. import org.junit.Test;
  3. public class ReflectionTest {
  5.     //反射之前，对于Person的操作
  6.     @Test
  7.     public void test(){
  9.         //1.创建类的对象
  10.         Person p1 = new Person("gaox",21);
  12.         //2.调用对象,调用其内部的属性和方法
  13.         p1.age = 15;
  14.         System.out.println(p1.toString());
  16.         p1.show();
  18.         //在Person类的外部，不可以通过Person类的对象调用其内部私有的结构。
  19.         //比如：name、showNation以及私有的构造器。
  21.     }
  22. }

Person类

  2. package github;
  4. public class Person {
  5.     private String name;
  6.     public int age;
  8.     public String getName() {
  9.         return name;
  10.     }
  12.     public void setName(String name) {
  13.         this.name = name;
  14.     }
  16.     public int getAge() {
  17.         return age;
  18.     }
  20.     public void setAge(int age) {
  21.         this.age = age;
  22.     }
  24.     public Person() {
  26.     }
  28.     public Person(String name, int age) {
  29.         this.name = name;
  30.         this.age = age;
  31.     }
  33.     private Person(String name) {
  34.         this.name = name;
  35.     }
  37.     @Override
  38.     public String toString() {
  39.         return "Person{" +
  40.                 "name='" + name + '\'' +
  41.                 ", age=" + age +
  42.                 '}';
  43.     }
  45.     public void show(){
  46.         System.out.println("你好，我是🔔");
  47.     }
  49.     private String showNation(String nation){
  50.         System.out.println("喷子实在太多了！！！" + nation);
  51.         return nation;
  52.     }
  53. }

1.1、使用反射，实现同上的操作

  2. import org.junit.Test;
  4. import java.lang.reflect.Constructor;
  5. import java.lang.reflect.Field;
  6. import java.lang.reflect.InvocationTargetException;
  7. import java.lang.reflect.Method;
  9. public class ReflectionTest {
  11.     //反射之后 ，堆与Person的操作
  12.     @Test
  13.     public void test2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
  14.         Class clazz = Person.class;
  15.         //1.通过反射，创建Person类的对象
  16.         Constructor cons = clazz.getConstructor(String.class,int.class);
  17.         Object obj = cons.newInstance("Jon",18);
  18.         Person p = (Person) obj;
  19.         System.out.println(p.toString());
  20.         //2.通过反射，调用对象指定的属性和方法
  21.         //调用属性
  22.         Field age = clazz.getDeclaredField("age");
  23.         age.set(p,10);
  24.         System.out.println(p.toString());
  26.         //调用方法
  27.         Method show = clazz.getDeclaredMethod("show");
  28.         show.invoke(p);
  30.     }
  31. }

1.2、反射的强大：调用类的私有结构

  2. import org.junit.Test;
  4. import java.lang.reflect.Constructor;
  5. import java.lang.reflect.Field;
  6. import java.lang.reflect.Method;
  8. public class ReflectionTest {
  9.      //反射之后 ，堆与Person的操作
  10.     @Test
  11.     public void test2() throws Exception{
  12.         Class clazz = Person.class;
  13.         //1.通过反射，创建Person类的对象
  14.         Constructor cons = clazz.getConstructor(String.class,int.class);
  15.         Object obj = cons.newInstance("Jon",18);
  16.         Person p = (Person) obj;
  17.         System.out.println(p.toString());
  18.         //2.通过反射，调用对象指定的属性和方法
  19.         //调用属性
  20.         Field age = clazz.getDeclaredField("age");
  21.         age.set(p,10);
  22.         System.out.println(p.toString());
  24.         //调用方法
  25.         Method show = clazz.getDeclaredMethod("show");
  26.         show.invoke(p);
  28.         System.out.println("+++++++++++++++++++++++++");
  30.         //通过反射，是可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
  31.         //调用私有的构造器
  32.         Constructor cons2 = clazz.getDeclaredConstructor(String.class);
  33.         cons2.setAccessible(true);
  34.         Person p1 = (Person) cons2.newInstance("kalo");
  35.         System.out.println(p1);
  37.         //调用私有的属性
  38.         Field name = clazz.getDeclaredField("name");
  39.         name.setAccessible(true);
  40.         name.set(p1,"Taoyao");
  41.         System.out.println(p1);
  43.         //调用私有的方法
  44.         Method showNation = clazz.getDeclaredMethod("LiNin", String.class);
  45.         showNation.setAccessible(true);
  46.         String nation = (String) showNation.invoke(p1,"FaceBook");
  47.         //相当于String nation = p1.showNation("FaceBook")
  48.         System.out.println(nation);
  49.     }
  51.     /**
  52.      * 疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
  53.      * 建议：直接new的方式。
  54.      * 什么时候会使用：反射的方式。 反射的特征：动态性
  55.      * 疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
  56.      * 不矛盾。
  57.      */
  58. }

02、理解Class类并获取Class实例

2.3、Class类的理解

关于java.lang.Class类的理解

类的加载过程

程序经过Javac.exe命令后，会生成一个或多个字节码文件(.class结尾)。
接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
换句话说，Class的实例就对应着一个运行时类。

Class类的常用方法

image.png

2.4、获取Class实例的4种方式

  2. import org.junit.Test;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.reflect.Constructor;
  6. import java.lang.reflect.Field;
  7. import java.lang.reflect.Method;
  9. public class ReflectionTest {
  11.     /**
  12.      * 2.换句话说，Class的实例就对应着一个运行时类。
  13.      * 3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式
  14.      * 来获取此运行时类。
  15.      */
  17.     @Test
  18.     public void test3() throws ClassNotFoundException {
  19.         //方式一：
  20.         Class c1 = Person.class;
  21.         System.out.println(c1);
  23.         //方式二：通过运行时类的对象,调用getClass()
  24.         Person p1 = new Person();
  25.         Class c2 = p1.getClass();
  26.         System.out.println(c2);
  28.         //方式三：调用Class的静态方法：forName(String classPath)
  29.         Class c3 = Class.forName("www.gh110.com");
  30.         // c3 = Class.forName("www.123.com");
  31.         System.out.println(c3);
  33.         System.out.println(c1 == c2);
  34.         System.out.println(c1 == c3);
  36.         //方式四：使用类的加载器：ClassLoader  (了解)
  37.         ClassLoader classLoader = ReflectionTest.class.getClassLoader();
  38.         Class c4 = classLoader.loadClass("www.gh110.com");
  39.         System.out.println(c4);
  41.         System.out.println(c1 == c4);
  42.     }
  43. }

2.5、Class实例对应的结构的说明

1、哪些类型可以有Class对象？

  1. class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
  2. interface：接口
  3. []：数组
  4. enum：枚举
  5. annotation：注解@interface
  6. primitivetype：基本数据类型
  7. void
  1. import org.junit.Test;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  7. public class ReflectionTest {
  9.     //万事万物皆对象？对象.xxx,File,URL,反射,前端、数据库操作
  11.     /**
  12.      * Class实例可以是哪些结构的说明：
  13.      */
  14.     @Test
  15.     public void test4() {
  16.         Class s1 = Object.class;
  17.         Class s2 = Comparable.class;
  18.         Class s3 = String[].class;
  19.         Class s4 = int[][].class;
  20.         Class s5 = ElementType.class;
  21.         Class s6 = Override.class;
  22.         Class s7 = int.class;
  23.         Class s8 = void.class;
  24.         Class s9 = Class.class;
  26.         int[] a = new int[10];
  27.         int[] b = new int[100];
  28.         Class s10 = a.getClass();
  29.         Class s11 = b.getClass();
  30.         // 只要数组的元素类型与维度一样，就是同一个Class
  31.         System.out.println(s10 == s11);
  32.     }
  33. }

03、类的加载与ClassLoader的理解

3.6、了解：类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

image.png

类的加载过程说明

加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

链接

将Java类的二进制代码合并到JVM的运行状态之中的过程。

验证

确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题

准备

正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

解析

虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化

执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

image.png

3.7、了解：什么时候会发生类初始化？

类的主动引用（一定会发生类的初始化）

  1. 当虚拟机启动，先初始化main方法所在的类
  2. new一个类的对象
  3. 调用类的静态成员（除了final常量）和静态方法
  4. 使用java.lang.reflect包的方法对类进行反射调用
  5. 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用（不会发生类的初始化）

  1. 当访问一个静态域时，只有真正声明这个域的类才会被初始化
    1. 当通过子类引用父类的静态变量，不会导致子类初始化
  2. 通过数组定义类引用，不会触发此类的初始化
  3. 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

3.8、ClassLoader的理解

image.png

类加载器的作用

类加载的作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类缓存

标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。
image.png

  1. import org.junit.Test;
  3. /**
  4.  * 了解类的加载器
  5.  *
  6.  */
  7. public class ClassLoaderTest {
  9.     @Test
  10.     public void test1(){
  11.         //对于自定义类，使用系统类加载器进行加载
  12.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
  13.         System.out.println(classLoader);
  14.         //调用系统类加载器的getParent()：获取扩展类加载器
  15.         ClassLoader classLoader1 = classLoader.getParent();
  16.         System.out.println(classLoader1);
  17.         //调用扩展类加载器的getParent()：无法获取引导类加载器
  18.         //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
  19.         ClassLoader classLoader2 = classLoader1.getParent();
  20.         System.out.println(classLoader2);
  22.         ClassLoader classLoader3 = String.class.getClassLoader();
  23.         System.out.println(classLoader3);
  24.     }
  25. }

3.9、使用ClassLoader加载配置文件

image.png

  1. import org.junit.Test;
  3. import java.io.InputStream;
  4. import java.util.Properties;
  6. /**
  7.  * 了解类的加载器
  8.  */
  9. public class ClassLoaderTest {
  11.     /**
  12.      * Properties：用来读取配置文件。
  13.      * @throws Exception
  14.      */
  15.     @Test
  16.     public void test2() throws Exception {
  17.         Properties pros = new Properties();
  18.         //此时的文件默认在当前的module下。
  19.         //读取配置文件的方式一：
  20.         // FileInputStream fis = new FileInputStream("jdbc.properties");
  21.         // pros.load(fis);
  23.         //读取配置文件的方式二：使用ClassLoader
  24.         //配置文件默认识别为：当前module的src下
  25.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
  26.         InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
  27.         pros.load(is);
  29.         String user = pros.getProperty("user");
  30.         String password = pros.getProperty("password");
  31.         System.out.println("user = " + user + ",password = " + password);
  32.     }
  33. }

04、通过反射，创建运行时类的对象

  2. import org.junit.Test;
  4. /**
  5.  * 通过发射创建对应的运行时类的对象
  6.  */
  7. public class NewInstanceTest {
  9.     @Test
  10.     public void test() throws Exception {
  11.         Class<Person> clazz = Person.class;
  12.         /**
  13.          * newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
  14.          *
  15.          * 要想此方法正常的创建运行时类的对象，要求：
  16.          * 1.运行时类必须提供空参的构造器
  17.          * 2.空参的构造器的访问权限得够。通常，设置为public。
  18.          *
  19.          * 在javabean中要求提供一个public的空参构造器。原因：
  20.          * 1.便于通过反射，创建运行时类的对象
  21.          * 2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
  22.          */
  23.         Person obj = clazz.newInstance();
  24.         System.out.println(obj);
  25.     }
  26. }

4.1、举例体会反射的动态性

  1. import org.junit.Test;
  2. import java.util.Random;
  4. /**
  5.  * 通过发射创建对应的运行时类的对象
  6.  */
  7. public class NewInstanceTest {
  9.     @Test
  10.     public void test2(){
  11.         for(int i = 0;i < 100;i++){
  12.             int num = new Random().nextInt(3);//0,1,2
  13.             String classPath = "";
  14.             switch(num){
  15.                 case 0:
  16.                     classPath = "java.util.Date";
  17.                     break;
  18.                 case 1:
  19.                     classPath = "java.lang.Object";
  20.                     break;
  21.                 case 2:
  22.                     classPath = "www.java.Person";
  23.                     break;
  24.             }
  25.             try {
  26.                 Object obj = getInstance(classPath);
  27.                 System.out.println(obj);
  28.             } catch (Exception e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  34.     /**
  35.      * 创建一个指定类的对象。
  36.      * classPath:指定类的全类名
  37.      *
  38.      * @param classPath
  39.      * @return
  40.      * @throws Exception
  41.      */
  42.     public Object getInstance(String classPath) throws Exception {
  43.         Class clazz =  Class.forName(classPath);
  44.         return clazz.newInstance();
  45.     }
  46. }

05、获取运行时类的完整结构

5.1、提供结构丰富Person类

1、Person类

  1. @MyAnnotation(value="java")
  2. public class Person extends Creature<String> implements Comparable<String>,MyInterface{
  4.     private String name;
  5.     int age;
  6.     public int id;
  8.     public Person() {
  9.     }
  11.     @MyAnnotation(value="C++")
  12.     Person(String name){
  13.         this.name = name;
  14.     }
  16.     private Person(String name,int age){
  17.         this.name = name;
  18.         this.age = age;
  19.     }
  21.     @MyAnnotation
  22.     private String show(String nation){
  23.         System.out.println("我来自" + nation + "星系");
  24.         return nation;
  25.     }
  27.     @Override
  28.     public void info() {
  29.         System.out.println("火星喷子");
  30.     }
  32.     public String display(String play){
  33.         return play;
  34.     }
  36.     @Override
  37.     public int compareTo(String o) {
  38.         return 0;
  39.     }
  40. }

2、Creature类

  1. import java.io.Serializable;
  3. public abstract class Creature <T> implements Serializable {
  4.     private char gender;
  5.     public double weight;
  7.     private void breath(){
  8.         System.out.println("太阳系");
  9.     }
  11.     public void eat(){
  12.         System.out.println("银河系");
  13.     }
  14. }

3、MyInterface

  1. public interface MyInterface {
  2.     void info();
  3. }

4、MyAnnotation

  1. import java.lang.annotation.Retention;
  2. import java.lang.annotation.RetentionPolicy;
  3. import java.lang.annotation.Target;
  5. import static java.lang.annotation.ElementType.*;
  7. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
  8. @Retention(RetentionPolicy.RUNTIME)
  9. public @interface MyAnnotation {
  10.     String value() default "hello world";
  11. }

5.2、获取运行时类的属性结构及其内部结构

1、Person类

  2. package github2;
  4. @MyAnnotation(value="java")
  5. public class Person extends Creature<String> implements Comparable<String>,MyInterface{
  7.     private String name;
  8.     int age;
  9.     public int id;
  11.     public Person() {
  12.     }
  14.     @MyAnnotation(value="C++")
  15.     Person(String name){
  16.         this.name = name;
  17.     }
  19.     private Person(String name,int age){
  20.         this.name = name;
  21.         this.age = age;
  22.     }
  24.     @MyAnnotation
  25.     private String show(String nation){
  26.         System.out.println("我来自" + nation + "星系");
  27.         return nation;
  28.     }
  30.     @Override
  31.     public void info() {
  32.         System.out.println("火星喷子");
  33.     }
  35.     public String display(String play){
  36.         return play;
  37.     }
  39.     @Override
  40.     public int compareTo(String o) {
  41.         return 0;
  42.     }
  43. }

2、测试类

  1. import github2.Person;
  2. import org.junit.Test;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Modifier;
  7. /**
  8.  * 获取当前运行时类的属性结构
  9.  */
  10. public class FieldTest {
  12.     @Test
  13.     public void test(){
  14.         Class clazz = Person.class;
  15.         //获取属性结构
  16.         //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
  17.         Field[] fields = clazz.getFields();
  18.         for(Field f : fields){
  19.             System.out.println(f);
  20.         }
  21.         System.out.println("++++++++++++++++++");
  22.         //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
  23.         Field[] declaredFields = clazz.getDeclaredFields();
  24.         for(Field f : declaredFields){
  25.             System.out.println(f);
  26.         }
  27.     }
  29.     //权限修饰符  数据类型 变量名
  30.     @Test
  31.     public void test2(){
  32.         Class clazz = Person.class;
  33.         Field[] declaredFields = clazz.getDeclaredFields();
  34.         for(Field f : declaredFields){
  35.             //1.权限修饰符
  36.             int modifier = f.getModifiers();
  37.             System.out.print(Modifier.toString(modifier) + "\t");
  38.             System.out.println("+++++++++++++++++++++++++++");
  39.             //2.数据类型
  40.             Class type = f.getType();
  41.             System.out.print(type.getName() + "\t");
  42.             System.out.println("***************************");
  43.             //3.变量名
  44.             String fName = f.getName();
  45.             System.out.print(fName);
  46.         }
  47.     }
  48. }

5.3、获取运行时类的方法结构

1、Person类

  1. package github2;
  3. @MyAnnotation(value="java")
  4. public class Person extends Creature<String> implements Comparable<String>,MyInterface{
  6.     private String name;
  7.     int age;
  8.     public int id;
  10.     public Person() {
  11.     }
  13.     @MyAnnotation(value="C++")
  14.     Person(String name){
  15.         this.name = name;
  16.     }
  18.     private Person(String name,int age){
  19.         this.name = name;
  20.         this.age = age;
  21.     }
  23.     @MyAnnotation
  24.     private String show(String nation){
  25.         System.out.println("我来自" + nation + "星系");
  26.         return nation;
  27.     }
  29.     @Override
  30.     public void info() {
  31.         System.out.println("火星喷子");
  32.     }
  34.     public String display(String play){
  35.         return play;
  36.     }
  38.     @Override
  39.     public int compareTo(String o) {
  40.         return 0;
  41.     }
  42. }

2、测试类

  1. package github3;
  3. import github2.Person;
  4. import org.junit.Test;
  6. import java.lang.reflect.Method;
  8. /**
  9.  * 获取运行时类的方法结构
  10.  */
  11. public class MythodTest {
  12.     @Test
  13.     public void test(){
  14.         Class clazz = Person.class;
  15.         //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
  16.         Method[] methods = clazz.getMethods();
  17.         for(Method m : methods){
  18.             System.out.println(m + "****");
  19.         }
  20.         System.out.println("++++++++++++++++++++++++++++");
  21.         //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
  22.         Method[] declaredMethods = clazz.getDeclaredMethods();
  23.         for(Method m : declaredMethods){
  24.             System.out.println(m);
  25.         }
  26.     }
  27. }

5.4、获取运行时类的方法的内部结构

1、Person类

  1. @MyAnnotation(value="java")
  2. public class Person extends Creature<String> implements Comparable<String>,MyInterface{
  4.     private String name;
  5.     int age;
  6.     public int id;
  8.     public Person() {
  9.     }
  11.     @MyAnnotation(value="C++")
  12.     Person(String name){
  13.         this.name = name;
  14.     }
  16.     private Person(String name,int age){
  17.         this.name = name;
  18.         this.age = age;
  19.     }
  21.     @MyAnnotation
  22.     private String show(String nation){
  23.         System.out.println("我来自" + nation + "星系");
  24.         return nation;
  25.     }
  27.     @Override
  28.     public void info() {
  29.         System.out.println("火星喷子");
  30.     }
  32.     public String display(String interests,int age) throws Exception{
  33.         return interests + age;
  34.     }
  36.     @Override
  37.     public int compareTo(String o) {
  38.         return 0;
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "Person{" +
  44.                 "name='" + name + '\'' +
  45.                 ", age=" + age +
  46.                 ", id=" + id +
  47.                 '}';
  48.     }
  49. }

2、测试类

  1. package github3;
  3. import github2.Person;
  4. import org.junit.Test;
  6. import java.lang.annotation.Annotation;
  7. import java.lang.reflect.Method;
  8. import java.lang.reflect.Modifier;
  10. /**
  11.  * 获取运行时类的方法结构
  12.  */
  13. public class MythodTest {
  15.     /**
  16.      * @Xxxx
  17.      * 权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
  18.      */
  19.     @Test
  20.     public void test2() {
  21.         Class clazz = Person.class;
  22.         Method[] declaredMethods = clazz.getDeclaredMethods();
  23.         for (Method m : declaredMethods) {
  24.             //1.获取方法声明的注解
  25.             Annotation[] annos = m.getAnnotations();
  26.             for (Annotation a : annos) {
  27.                 System.out.println(a + "KKKK");
  28.             }
  30.             //2.权限修饰符
  31.             System.out.print(Modifier.toString(m.getModifiers()) + "\t");
  33.             //3.返回值类型
  34.             System.out.print(m.getReturnType().getName() + "\t");
  36.             //4.方法名
  37.             System.out.print(m.getName());
  38.             System.out.print("(");
  39.             //5.形参列表
  40.             Class[] pTs = m.getParameterTypes();
  41.             if(!(pTs == null && pTs.length == 0)){
  42.                 for(int i = 0;i < pTs.length;i++){
  43.                     if(i == pTs.length - 1){
  44.                         System.out.print(pTs[i].getName() + " args_" + i);
  45.                         break;
  46.                     }
  47.                     System.out.print(pTs[i].getName() + " args_" + i + ",");
  48.                 }
  49.             }
  50.             System.out.print(")");
  52.             //6.抛出的异常
  53.             Class[] eTs = m.getExceptionTypes();
  54.             if(eTs.length > 0){
  55.                 System.out.print("throws ");
  56.                 for(int i = 0;i < eTs.length;i++){
  57.                     if(i == eTs.length - 1){
  58.                         System.out.print(eTs[i].getName());
  59.                         break;
  60.                     }
  61.                     System.out.print(eTs[i].getName() + ",");
  62.                 }
  63.             }
  64.             System.out.println("TQA");
  65.         }
  66.     }
  67. }

5.5、获取运行时类的构造器结构

  1. package github3;
  3. import github2.Person;
  4. import org.junit.Test;
  6. import java.lang.reflect.Constructor;
  8. public class OtherTest {
  9.     /**
  10.      * 获取构造器的结构
  11.      */
  12.     @Test
  13.     public void test(){
  14.         Class clazz = Person.class;
  15.         //getConstructors():获取当前运行时类中声明为public的构造器
  16.         Constructor[] constructors = clazz.getConstructors();
  17.         for(Constructor c : constructors){
  18.             System.out.println(c);
  19.         }
  20.         System.out.println("************************");
  21.         //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
  22.         Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
  23.         for(Constructor c : declaredConstructors){
  24.             System.out.println(c);
  25.         }
  26.     }
  27. }

5.6、获取运行时类的父类及父类的泛型

  1. package github3;
  3. import github2.Person;
  4. import org.junit.Test;
  6. import java.lang.reflect.Constructor;
  7. import java.lang.reflect.ParameterizedType;
  8. import java.lang.reflect.Type;
  10. public class OtherTest {
  11.     /**
  12.      * 获取运行时类的父类
  13.      */
  14.     @Test
  15.     public void test2(){
  16.         Class clazz = Person.class;
  17.         Class superclass = clazz.getSuperclass();
  18.         System.out.println(superclass);
  19.     }
  21.     /**
  22.      * 获取运行时类的带泛型的父类
  23.      */
  24.     @Test
  25.     public void test3(){
  26.         Class clazz = Person.class;
  27.         Type genericSuperclass = clazz.getGenericSuperclass();
  28.         System.out.println(genericSuperclass);
  29.     }
  31.     /**
  32.      * 获取运行时类的带泛型的父类的泛型
  33.      */
  34.     @Test
  35.     public void test4(){
  36.         Class clazz = Person.class;
  37.         Type genericSuperclass = clazz.getGenericSuperclass();
  38.         ParameterizedType paramType = (ParameterizedType) genericSuperclass;
  39.         //获取泛型类型
  40.         Type[] actualTypeArguments = paramType.getActualTypeArguments();
  41. //        System.out.println(actualTypeArguments[0].getTypeName());
  42.         System.out.println(((Class)actualTypeArguments[0]).getName());
  43.     }
  44. }

5.7、获取运行时类的接口、所在包、注解等

  1. package github3;
  3. import github2.Person;
  4. import org.junit.Test;
  6. import java.lang.annotation.Annotation;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.ParameterizedType;
  9. import java.lang.reflect.Type;
  11. public class OtherTest {
  12.     /**
  13.      * 获取运行时类实现的接口
  14.      */
  15.     @Test
  16.     public void test5(){
  17.         Class clazz = Person.class;
  19.         Class[] interfaces = clazz.getInterfaces();
  20.         for(Class c : interfaces){
  21.             System.out.println(c);
  22.         }
  23.         System.out.println("++++++++++++++++++++++");
  25.         //获取运行时类的父类实现的接口
  26.         Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
  27.         for(Class c : interfaces1){
  28.             System.out.println(c);
  29.         }
  30.     }
  32.     /**
  33.      * 获取运行时类所在的包
  34.      */
  35.     @Test
  36.     public void test6(){
  37.         Class clazz = Person.class;
  38.         Package pack = clazz.getPackage();
  39.         System.out.println(pack);
  40.     }
  42.     /**
  43.      * 获取运行时类声明的注解
  44.      */
  45.     @Test
  46.     public void test7(){
  47.         Class clazz = Person.class;
  48.         Annotation[] annotations = clazz.getAnnotations();
  49.         for(Annotation annos : annotations){
  50.             System.out.println(annos);
  51.         }
  52.     }