12-Java的反射_不确定的对象用反射-CSDN博客

本文链接：https://blog.csdn.net/qq_45632660/article/details/109682558

本文深入探讨了Java反射机制，包括如何在运行时获取类的内部信息、创建对象、调用属性和方法，以及如何处理泛型、注解和动态代理。详细介绍了Class、Method、Field和Constructor等反射API的使用，并分析了反射与封装性的关系。同时，讲解了类的加载过程、类加载器的工作原理以及获取运行时类结构的方法。此外，还展示了反射在创建对象、调用方法和构造器等方面的动态性。

摘要由CSDN通过智能技术生成

1、概述

Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为: 反射

在这里插入图片描述

1.1、Java反射机制研究及应用

Java反射机制提供的功能

1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法
4.在运行时获取泛型信息
5.在运行时调用任意一个对象的成员变量和方法
6.在运行时处理注解
7.生成动态代理

@Test
public void test1() throws Exception {
    Class<Person> clazz = Person.class;
    //1.通过反射，创建Person类对象
    Constructor<Person> cons = clazz.getConstructor(String.class, int.class);
    Person person = cons.newInstance("Tom", 12);
    System.out.println(person);//Person{name='Tom', age=12}

    //2.通过反射，调用对象指定的属性、方法
    //调用属性
    Field age = clazz.getDeclaredField("age");
    age.setAccessible(true);
    age.set(person, 10);
    System.out.println(person.toString());//Person{name='Tom', age=10}

    //调用方法
    Method show = clazz.getDeclaredMethod("show");
    show.invoke(person);//my name is Tom and age is 10

    System.out.println("===================================");
    //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
    //调用私有的构造器
    Constructor<Person> cons1 = clazz.getDeclaredConstructor(String.class);
    cons1.setAccessible(true);
    Person p1 = cons1.newInstance("Bruce");
    System.out.println(p1);//Person{name='Bruce', age=0}

    //调用私有的属性
    Field name = clazz.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p1, "Jarry");
    System.out.println(p1);

    //调用私有的方法
    Method nation = clazz.getDeclaredMethod("nation", String.class);
    nation.setAccessible(true);
    Object nation1 = (String) nation.invoke(p1, "China");//相当于String nation = p1.showNation("China")
    System.out.println(nation1);//I come from China
}

1.2、反射相关的主要API

java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
… …

1.3、如何看待反射和封装性两个技术

疑问1: 通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用哪个?

建议: 直接new的方式。

什么时候会使用: 反射的方式。编译期不确定对象的情况下使用反射。

反射的特征: 动态性。

疑问2: 反射机制与面向对象中的封装性是不是矛盾的? 如何看待两个技术?

不矛盾

反射: 能不能调用

面向对象: 调用哪个比较好

2、Class类

2.1、Class类的理解

1.类的加载过程:

程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。

接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称

为类的加载。记载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。

2.换句话说,Class的实例就对应着一个运行时类。

3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

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

获取Class实例的4种方式(前三种需要掌握)

//第一种 调用运行时类的属性.class
Class class1 = Persion.class

//第二种 通过运行时类的对象，调用getClass()
Persion p = new Persion
System.out.println(p.getClass())

//第三种 调用Class的静态方法: forName(String classPath)
Class class3 = Class.forName(String classPath)
System.out.println(class3)

//方式四: 使用类的加载器： ClassLoader(了解)
ClassLoader classLoader = ReflectionTest2.class.getClassLoader();
Class<?> aClass1 = classLoader.loadClass("FanShe.Persion");

//代码示例
    @Test
    public void test() throws ClassNotFoundException {
        //方式一: 调用运行时类的属性.class
        Class<Persion> persionClass = Persion.class;
        System.out.println(persionClass);
        //方式二: 通过运行时类的对象，调用getClass()
        Persion p = new Persion();
        Class aClass = p.getClass();
        System.out.println(aClass);

        //方式三: 调用Class的静态方法: forName(String classPath)
        Class name = Class.forName("FanShe.Persion");
        System.out.println(name);

        System.out.println(name == aClass);

        //方式四: 使用类的加载器： ClassLoader
        ClassLoader classLoader = ReflectionTest2.class.getClassLoader();
        Class<?> aClass1 = classLoader.loadClass("FanShe.Persion");
        System.out.println(aClass1);
        System.out.println(name == aClass1);
    }

2.3、Class实例可以代表的结构

class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类

（2）interface：接口

（3）[]：数组

（4）enum：枚举

（5）annotation：注解@interface

（6）primitive type：基本数据类型

（7）void

//代码示例
@Test
public void test3(){
    Class<Object> c1 = Object.class;
    Class<Comparable> c2 = Comparable.class;
    Class<String[]> c3 = String[].class;
    Class<int[][]> c4 = int[][].class;
    Class<ElementType> c5 = ElementType.class;
    Class<Override> c6 = Override.class;
    Class<Integer> c7 = int.class;
    Class<Void> c8 = void.class;
    Class<Class> c9 = Class.class;

    int[] i1 = new int[10];
    int[] i2 = new int[100];
    Class<? extends int[]> c10 = i1.getClass();
    Class<? extends int[]> c11 = i2.getClass();
    // 只要数组的元素类型与维度一样，就是同一个Class
    System.out.println(c10 == c11);//true
}

2.5、理解类的加载过程

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

在这里插入图片描述

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。
- 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题。
- 准备：正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
初始化：
- 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

2.6、类加载器

在这里插入图片描述

类加载器的作用：
1.类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方
法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
2.类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

2.7、类加载器的分类

在这里插入图片描述

 @Test
    public void test2(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ReflectionTest2.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
        //调用系统类加载器的getParent():获取扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@8efb846
        //调用扩展类加载器的getParent():无法获取引导类加载器
        //引导类加载器主要负责记载java的核心类库，无法加载自定义类的。
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//null
    }

使用Classloader加载src目录下的配置文件

@Test
public void test3(){
    Properties pros = new Properties();
    //        //读取配置文件的方式一：
    //        //此时的文件默认在当前的module下。
    //        FileInputStream fis = null;
    //        try {
    //            fis = new FileInputStream("jdbc1.properties");
    //            pros.load(fis);
    //        } catch (IOException e) {
    //            e.printStackTrace();
    //        } finally {
    //            if (fis != null) {
    //                try {
    //                    fis.close();
    //                } catch (IOException e) {
    //                    e.printStackTrace();
    //                }
    //            }
    //        }

    //读取配置文件的方式二：使用ClassLoader
    //配置文件默认识别为：当前module的src下
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
    try {
        pros.load(is);
    } catch (IOException e) {
        e.printStackTrace();
    }

    String user = pros.getProperty("user");
    String password = pros.getProperty("password");
    System.out.println("user = " + user + " password =" + password);
}

3、反射的应用

3.1、创建运行时类的对象

newInstance():调用此方法，创建对应的运行时类的对象，内部调用了运行时类的空参构造器
要想此方法正常的创建运行时类的对象，要求:
1.运行时类必须提供空参构造器
2.空参的构造器的访问权限得够。通常，设置为public
    
在javabean中要求提供一个public的空参构造器。原因:
1.便于通过反射，创建运行时类的对象
2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器。

//代码示例
 Class<?> aClass = Class.forName("FanShe.Persion");
        //o就是Persion类的实例对象
        //newInstance():调用此方法，创建对应的运行时类的对象，内部调用了运行时类的空参构造器
        Object o = aClass.newInstance();
        System.out.println(o);

3.2、反射的动态性

体验反射的动态性

//代码举例
 @Test
    public void test5() throws ClassNotFoundException {
        int i = 1;
        while (i<=100){
            int num = new Random().nextInt(3);
            String classPath = "";
            switch (num){
                case 0:
                    classPath = "java.util.Date";
                    break;
                case 1:
                    classPath = "java.lang.Object";
                case 2:
                    classPath = "FanShe.Persion";
            }
            Object instance = getInstance(classPath);
            System.out.println(instance);
            i++;
        }
    }
    /*
    创建一个指定类的对象
    classPath: 指定类的全类名
     */
    public Object getInstance(String classPath) throws ClassNotFoundException {
        Class<?> aClass = Class.forName(classPath);
        return aClass;
    }

3.3、获取运行类的完整结构(了解)

我们可以通过反射，获取对应的运行时类中所有的属性、方法、构造器、父类、接口、父类的泛型、包、注解、异常等。。。。

获取属性

getFields(); //获取当前运行时类及其父类中声明为public访问权限的属性、

getDeclaredFields(): //获取当前运行时类的声明的所有的属性(不包含父类中声明的属性)

@org.junit.Test
public void test(){
        Class<Person> aClass = Person.class;
        //获取属性结构
        //getFields(); //获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = aClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("*****************");
        //getDeclaredFields():获取当前运行时类的声明的所有的属性(不包含父类中声明的属性)
        Field[] fields1 = aClass.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
    }

获取属性的权限修饰符数据类型变量名

getModifiers()；//获取权限修饰符

getType(); //获取数据类型

getName(); //获取变量名

@Test
    public void test2(){
        Class<Person> aclass = Person.class;
        Field[] fields = aclass.getDeclaredFields();
        for (Field field : fields) {
            //权限修饰符
            int modifiers = field.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");
            //数据类型
            Class<?> type = field.getType();
            System.out.print(type.getName() + "\t");
            //变量名
            String name = field.getName();
            System.out.println(name + "\t");
        }
    }

获取方法

getMethods(): //获取当前运行时类及其所有父类中声明为public权限的方法

getDeclaredMethods(): //获取当前运行时类中声明的所有方法。(不包含父类中的方法)

@Test
    public void test3(){
        Class<Person> aClass = Person.class;
        //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            //System.out.println(method);
        }
        //getDeclaredMethods():获取当前运行时类中声明的所有方法。(不包含父类中的方法)
        Method[] method = aClass.getDeclaredMethods();
        for (Method method1 : method) {
            System.out.println(method1);
        }

    }

获取方法的权限修饰符返回值类型方法名(参数类型1 形参1,…) thrwos XxxException{} 注解

getAnnotations(); //获取方法声明的注解

getModifiers(); //获取权限修饰符

getReturnType(); // 获取返回值类型

getName(); // 获取方法名

getParameterTypes(); //获取参数类型

getExceptionTypes(); //获取异常

// 代码示例
@Test
    public void test4(){
        Class<Person> aClass = Person.class;
        Method[] methods = aClass.getDeclaredMethods();
        for (Method method : methods) {
            //获取方法声明的注解
            Annotation[] annotations = method.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.print(annotation + "\t");
            }
            //获取权限修饰符
            int modifiers = method.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");

            //获取返回值类型
            Type returnType = method.getReturnType();
            System.out.print(returnType + "\t");

            //获取方法名
            System.out.print(method.getName() + "\t");
            //获取形参列表
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (!(parameterTypes == null && parameterTypes.length == 0)) {
                for (int i = 0; i < parameterTypes.length; i++) {
                    if (i == parameterTypes.length - 1) {
                        System.out.println(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.println(parameterTypes[i].getName() + "args_" + i + ",");
                }
            }
            System.out.print(")");
            //抛出的异常
            Class<?>[] exceptionTypes = method.getExceptionTypes();
            if (exceptionTypes.length > 0){
                System.out.print("throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i==exceptionTypes.length -1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName()+",");
                }

                System.out.println();
            }
        }
    }

获取构造器

getConstructors(); //获取当前运行时类中声明为public的构造器

getDeclaredConstructors();//获取当前运行时类中声明的所有的构造器

//代码示例
 @Test
    public void test5(){
        Class<Person> personClass = Person.class;
        Constructor<?>[] constructors = personClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        Constructor<?>[] constructors1 = personClass.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors1) {
            System.out.println(constructor);
        }

    }

获取运行时类的父类

getSuperclass();//获取运行时类的父类

@Test
    public void test6(){
        Class<Person> aClass = Person.class;
        Class<? super Person> superclass = aClass.getSuperclass();
        System.out.println(superclass);
    }

获取运行时类带泛型的父类

getGenericSuperclass();//获取运行时类带泛型的父类

 @Test
    public void test6(){
        Class<Person> aClass = Person.class;
        Type superclass = aClass.getGenericSuperclass();
        System.out.println(superclass);
    }

获取运行时类带泛型的父类的泛型

@Test
    public void test6(){
        Class<Person> aClass = Person.class;
        Type superclass = aClass.getGenericSuperclass();
        ParameterizedType p = (ParameterizedType) superclass;
        //获取泛型的类型
        Type[] arguments = p.getActualTypeArguments();
        for (Type argument : arguments) {
            System.out.println(argument);
        }
    }

获取运行时类实现的接口

getInterfaces();//获取运行时类实现的接口

 @Test
    public void test7(){
        Class<Person> aClass = Person.class;
        Class<?>[] interfaces = aClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface);
        }
       
    }

获取运行时类所在的包

getPackage();//获取运行时类所在的包

@Test
    public void test8(){
        Class<Person> aClass = Person.class;
        Package aPackage = aClass.getPackage();
        System.out.println(aPackage);
    }

获取运行时类所在的注解

getAnnotations();//获取运行时类所在的注解

 @Test
    public void test9(){
        Class<Person> aClass = Person.class;
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }

3.4、调用运行时类的指定结构

调用运行时类的指定结构: 属性、方法、构造器

属性

实例化Class类
创建运行时类的对象
获取运行时类中指定变量名的属性
保证当前属性是可以访问的，无论什么访问权限。
设置当前属性的值
set(): 参数1: 指明设置哪个对象的属性
参数2: 将此属性值设置为多少
get(): 参数1: 获取哪个对象的当前属性值

//代码示例
@Test
    public void test() throws  Exception{
        Class<Person> aClass = Person.class;
        //创建运行时类的对象
        Person person = aClass.newInstance();
        //获取运行时类中指定变量名的属性
        Field id = aClass.getDeclaredField("id");
        //保证当前属性是可以访问的，无论什么访问权限。
        id.setAccessible(true);

        /*
        设置当前属性的值
        set(): 参数1: 指明设置哪个对象的属性
               参数2: 将此属性值设置为多少
         */
        id.set(person,1001);
        /*
        get(): 参数1: 获取哪个对象的当前属性值
         */
        Object o = id.get(person);
        System.out.println(o);
    }

方法(常用)

实例化Class类
创建运行时类的对象
获取指定的某个方法
getDeclaredMethod(参数1，参数2): 参数1: 指明获取的方法的名称
参数2: 指明获取的方法的形参列表
invoke(参数1，参数2): 参数1: 方法的调用者
参数2: 给方法形参赋值的实参
invoke()的返回值即为当前运行时类中调用的方法的返回值

//代码示例
 @Test
    public void test2()throws Exception{
        Class<Person> aClass = Person.class;
        //创建运行时类的对象
        Person person = aClass.newInstance();
        /*
        获取指定的某个方法
        getDeclaredMethod(): 参数1: 指明获取的方法的名称
                             参数2: 指明获取的方法的形参列表
         */
        Method show = aClass.getDeclaredMethod("show", String.class);
        show.setAccessible(true);
        /*
        invoke(): 参数1: 方法的调用者
                  参数2: 给方法形参赋值的实参
        invoke()的返回值即为当前运行时类中调用的方法的返回值
         */
        Object o = show.invoke(person, "CHN");

        System.out.println(o);
        System.out.println("********获取静态方法*******");
        Method desc = aClass.getDeclaredMethod("showDesc");
        desc.setAccessible(true);
        Object invoke = desc.invoke(Person.class);
        System.out.println(invoke);
    }

构造器

@Test
public void testConstructor() throws Exception {
    Class clazz = Person.class;

    //private Person(String name)
    /*
        1.获取指定的构造器
        getDeclaredConstructor():参数：指明构造器的参数列表
         */

    Constructor constructor = clazz.getDeclaredConstructor(String.class);

    //2.保证此构造器是可访问的
    constructor.setAccessible(true);

    //3.调用此构造器创建运行时类的对象
    Person per = (Person) constructor.newInstance("Tom");
    System.out.println(per);

}