Java反射

程序员正正

已于 2022-04-04 11:04:34 修改

阅读量781

点赞数

分类专栏： Java基础文章标签： java 开发语言后端

于 2022-02-28 20:19:45 首次发布

本文链接：https://blog.csdn.net/WXxz0/article/details/123191081

版权

Java基础专栏收录该内容

29 篇文章 1 订阅

订阅专栏

反射

反射机制

Java Reflection

反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量，构造器，成员方法等等)，并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象) ,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像面镜子，透过这个镜子看到类的结构，所以，形象的称之为: 反射

Java反射机制原理示意图！！！

![[外链图片转存失败,源站可能有防盗在这里插入图片描述

Java反射机制可以完成

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时得到任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理

反射相关的主要类

java.lang.Class:代表个类，Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法
java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量
java.lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器

这些类在java.lang.reflection

反射优点和缺点

优点:可以动态的创建和使用对象(也是框架底层核心)，使用灵活，没有反射机制，框架技术就失去底层支撑。
缺点:使用反射基本是解释执行，对执行速度有影响.

反射调用优化-关闭访问检查

Method和Field、 Constructor对象都有setAccessible0方法
setAccessible作用是启动和禁用访问安全检查的开关
参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-13oD5gxp-1646050585488)(C:\Users\许正\AppData\Roaming\Typora\typora-user-images\image-20220226191208618.png)]$

Class类

基本介绍

Class也是类，因此也继承Object类[类图]
Class类对象不是new出来的，而是系统创建的[演示]
对于某个类的Class类对象，在内存中只有一份，因为类只加载一次[演示]
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类的完整结构，通过一系列API
Class对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码，
变量名，方法名，访问权限等等) (https:/ /www.zhihu.com/question/38496907)

package com.xz.reflection.class_;

/**
 * @author 许正
 * @version 1.0
 * 对Class类特点的梳理
 */
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //看看Class类图
        //1. Class也是类，因此也继承Object类
        //CLass
        //2.Class类对象不是new出来的，而是系统创建的
        //(1) 传统new对象
        /* ClassLoader类
         public Class<?> loadClass(String name) throws ClassNotFoundException {
             return loadClass(name, false);
         }
        */
        Cat cat = new Cat();
        //(2) 反射方式
        Class cls1 = Class.forName("com.xz.reflection.Cat");

        //3.对于某个类的CLass类对象，在内存中只有一份，因为类只加载一次
        Class cls2 = Class.forName("com.xz.reflection.Cat");
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());

        Class cls3 = Class.forName("com.xz.reflection.Dog");
        System.out.println(cls3.hashCode());

    }

}

类图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cr4AZPqi-1646050585489)(C:\Users\许正\AppData\Roaming\Typora\typora-user-images\image-20220226192927785.png)]$

Class类的常用方法

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HLu36iGI-1646050585489)(C:\Users\许正\AppData\Roaming\Typora\typora-user-images\image-20220226200024350.png)]$

package com.xz.reflection.class_;

import com.xz.reflection.Car;

import java.lang.reflect.Field;

/**
 * @author 许正
 * @version 1.0
 */
public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {

        String classAllPath = "com.xz.reflection.Car";
        //1. 获取到Car类 对应的 Class 对象
        //<?> 表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls);//显示cls对象，是哪个类的Class对象 com.xz.reflection.Car
        System.out.println(cls.getClass());//输出cls的运行类型 java.lang.Class
        //3. 得到包名
        System.out.println(cls.getPackage().getName());
        //4. 得到全类名
        System.out.println(cls.getName());
        //5. 通过cls创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);
        //6. 通cls获取属性brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马
        //7. 通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));
        //8. 通过反射机制拿到所有的属性（字段）
        System.out.println("=========所有的属性（字段）:==========");
        for (Field field : cls.getFields()) {
            System.out.println(field.getName());//名称
        }


    }
}

获取 Class 对象的各种方式（6）

package com.xz.reflection.class_;

import com.xz.reflection.Car;

/**
 * @author 许正
 * @version 1.0
 * 演示得到 Class 对象的各种方式（6）
 */
public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName
        String classAllPath = "com.xz.reflection.Car";//通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2.类名.class,应用场景：多用于参数传递
        Class<Car> cls2 = Car.class;
        System.out.println(cls2);

        //3.对象.getClass(),应用场景：有对象实例
        Car car = new Car();
        Class<? extends Car> cls3 = car.getClass();
        System.out.println(cls3);

        //4.通过类加载器【4种】来获取到类的Class对象
        //(1)先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //cls1,cls2,cls3,cls4是同一个对象
        System.out.println("========================");
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5.基本数据(int,char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);//int

        //6. 基本数据类型对应的包装类,可以通过.TYPE得到Class类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1);

        //得到的integerClass 和 type1 也是同一个对象
        System.out.println("========================");
        System.out.println(integerClass.hashCode());
        System.out.println(type1.hashCode());


    }

}

哪些类型有Class对象

如下类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类
interface: 接口
数组
enum :枚举
annotation :注解
基本数据类型
void

package com.xz.reflection.class_;

import java.io.Serializable;

/**
 * @author 许正
 * @version 1.0
 * 演示哪些类型有Class对象
 */
public class AllTypeClass {
    public static void main(String[] args) {
        Class<String> cls1 = String.class;//外部类
        Class<Serializable> cls2 = Serializable.class;//接口
        Class<Integer[]> cls3 = Integer[].class;//数组
        Class<float[][]> cls4 = float[][].class;//二维数组
        Class<Deprecated> cls5 = Deprecated.class;//注解
        Class<Thread.State> cls6 = Thread.State.class;//枚举
        Class<Long> cls7 = long.class;//基础数据类型
        Class<Double> cls8 = Double.class;//包装类
        Class<Void> cls9 = void.class;//void数据类型
        Class<Class> cls10 = Class.class;

        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls4);
        System.out.println(cls5);
        System.out.println(cls6);
        System.out.println(cls7);
        System.out.println(cls8);
        System.out.println(cls9);
        System.out.println(cls10);


    }
}

类加载

基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。

静态加载:编译时加载相关的类，如果没有则报错，依赖性太强
动态加载:运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性

类加载时机

当创建对象时(new) //静态加载
当子类被加载时，父类也加载 //静态加载
调用类中的静态成员时 //静态加载
通过反射 //动态加载

类加载过程图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CX2iMpfP-1646050585490)(C:\Users\许正\AppData\Roaming\Typora\typora-user-images\image-20220227085051432.png)]$

类加载各阶段完成任务

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P0jwCbtc-1646050585490)(C:\Users\许正\AppData\Roaming\Typora\typora-user-images\image-20220227085402113.png)]$

加载阶段

JVM在该阶段的主要目的是将字节码从不同的数据源(可能是class文件、也可能是jar包，甚至网络)转化为进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

连接阶段-验证

目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
包括:文件格式验证(是否以魔数oxcafebabe开头)、元数据验证、字节码验证和符号引用验证
可以考虑使用-Xverify:none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。

连接阶段-准备

JVM会在该阶段对静态变量，分配内存并默认初始化(对应数据类型的默认初始值，如0、0L、 null、 false等) 。这些变量所使用的内存都将在方法区中进行分配

连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程。

Initialization (初始化)

到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行 ()方法的过程。
()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
虚拟机会保证一个类的 ()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 ()方法，其他线程都需要阻塞等待，直到活动线程执行 ()方法完毕

通过反射获取类的结构信息

第一组：java.lang.Class类

getName:获取全类名
getSimpleName:获取简单类名
getFields:获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields:获取本类中所有属性
getMethods:获取所有public修饰的方法，包含本类以及父类的
getDeclaredMethods:获取本类中所有方法
getConstructors: 获取本类public修饰的构造器
getDeclaredConstructors:获取本类中所有构造器
getPackage:以Package形式返回包信息
getSuperClass:以Class形式返回父类信息
getInterfaces:以Class[]形式返回接口信息
getAnnotations:以Annotation[]形式返回注解信息

第二组: java.lang.reflect.Field类

getModifiers:以int形式返回修饰符[说明:默认修饰符是0，public 是1 , private 是2 , protected 是4,static是8 , final 是16, 例如：public(1) + static (8) = 9
getType:以Class形式返回类型
getName:返回属性名

第三组: java.lang.reflect.Method类

getModifiers:以int形式返回修饰符[说明:默认修饰符是0，public 是1 , private 是2 , protected 是4,static是8，final 是16]
getReturnType:以Class形式获取返回类型
getName:返回方法名
getParameterTypes:以Class[]返回参数类型数组

第四组: java.lang.reflect.Constructor类

getModifiers:以int形式返回修饰符
getName:返回构造器名(全类名)
getParameterTypes:以Class[]返回参数类型数组

方法实例

package com.xz.reflection.question;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author 许正
 * @version 1.0
 * 演示如何通过反射获取类的结构信息
 */
public class ReflectionUtils {
    public static void main(String[] args) {

    }

    //演示方法
    @Test
    public void api_01() throws ClassNotFoundException {

        //得到Class对象
        Class<?> personCls = Class.forName("com.xz.reflection.question.Person");

//        1.  getName:获取全类名
        String name = personCls.getName();
        System.out.println(name);//com.xz.reflection.question.Person
//        2.  getSimpleName:获取简单类名
        System.out.println(personCls.getSimpleName());//Person
//        3.  getFields:获取所有public修饰的属性，包含本类以及父类的
        for (Field field : personCls.getFields()) {
            System.out.println("本类以及父类所有属性:" + field.getName());
        }
//        4.  getDeclaredFields:获取本类中所有属性
        for (Field declaredField : personCls.getDeclaredFields()) {
            System.out.println("本类中所有属性:" + declaredField.getName());
        }
//        5.  getMethods:获取所有public修饰的方法，包含本类以及父类的
        for (Method method : personCls.getMethods()) {
            System.out.println("本类及父类，超类的public修饰的方法:" + method.getName());
        }
//        6.  getDeclaredMethods:获取本类中所有方法
        for (Method declaredMethod : personCls.getDeclaredMethods()) {
            System.out.println("本类中所有方法:" + declaredMethod.getName());
        }
//        7.  getConstructors: 获取所有public修饰的构造器，包含本类的
        for (Constructor<?> constructor : personCls.getConstructors()) {
            System.out.println("本类public修饰的构造器:" + constructor.getName());
        }
//        8.  getDeclaredConstructors:获取本类中所有构造器
        for (Constructor<?> declaredConstructor : personCls.getDeclaredConstructors()) {
            System.out.println("本类的所有构造器:" + declaredConstructor.getName());
        }
//        9.  getPackage:以Package形式返回包信息
        System.out.println(personCls.getPackage());//com.xz.reflection.question
//        10.  getSuperClass:以Class形式返回父类信息
        System.out.println("父类信息:" + personCls.getSuperclass().getName());
//        11.  getInterfaces:以Class[]形式返回接口信息
        for (Class<?> anInterface : personCls.getInterfaces()) {
            System.out.println("接口信息:" + anInterface.getName());
        }
//        12.  getAnnotations:以Annotation[]形式返回注解信息
        for (Annotation annotation : personCls.getAnnotations()) {
            System.out.println("注解信息" + annotation);
        }


    }

    @Test
    public void api_02() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.xz.reflection.question.Person");
        //getDeclaredFields:获取本类中所有属性
        //规定：public 是1 , private 是2 , protected 是4,static是8 , final 是16
        for (Field declaredField : personCls.getDeclaredFields()) {
            System.out.println("本类中所有属性:" + declaredField.getName() + " 该属性的修饰符值:" + declaredField.getModifiers()
                    + " 该属性的类型：" + declaredField.getType());
        }

        //getDeclaredMethods:获取本类中所有方法
        for (Method declaredMethod : personCls.getDeclaredMethods()) {
            System.out.println("本类中所有方法:" + declaredMethod.getName()
                    + " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
                    + " 该方法的返回类型:" + declaredMethod.getReturnType());

            //输出当前的方法形参数组情况
            for (Class<?> parameterType : declaredMethod.getParameterTypes()) {
                System.out.println(" 该方法的形参类型:" + parameterType);
            }

        }

        //getDeclaredConstructors:获取本类中所有构造器
        for (Constructor<?> declaredConstructor : personCls.getDeclaredConstructors()) {
            System.out.println("=======================");
            System.out.println(" 本类的所有构造器:" + declaredConstructor.getName());

            for (Class<?> parameterType : declaredConstructor.getParameterTypes()) {
                System.out.println(" 该构造器的形参类型:" + parameterType);
            }

        }

    }
}

class A {
    public String hobby;

    public A() {

    }
}

interface IA {

}

interface IB {

}

@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    public Person() {
    }

    public Person(String name) {

    }

    //私有构造器
    private Person(String name, int age) {

    }

    //方法
    public void m1(String name, int age, double sal) {

    }

    protected String m2() {
        return null;
    }

    void m3() {
    }

    private void m4() {

    }
}

通过反射创建对象

方式一:调用类中的public修饰的无参构造器
方式二:调用类中的指定构造器
Class类相关方法
newInstance :调用类中的无参构造器，获取对应类的对象
getConstructor(Cas…clazz):根据参数列表，获取对应的构造器对象
getDecalaredConstructor(Cas…clazz):根据参数列表，获取对应的构造器对象
Constructor类相关方法
setAccessible:暴破 //暴破[暴力破解]，使用反射可以访间private构造器
newlnstance(Object…obj):调用构造器

通过反射访问类中的成员

访问属性

根据属性名获取Field对象
Field f = clazz对象.getDeclaredField(属性名);
暴破: f.setAccessible(true); //f是Field
访问
f.set(o,值);
syso(f.get(o));
如果是静态属性，则set和get中的参数o，可以写成null

访问方法

根据方法名和参数列表获取Method方法对象:
Method m =clazz.getDeclaredMethod(方法名，XX.class); //得到本类的所有方法
获取对象: Object o= clazz.newInstance();
暴破: m.setAacessible(true);
访问: Object returnValue = m.invoke(o,实参列表);
注意:如果是静态方法，则invoke的参数o,可以写成null!

程序员正正

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java反射

反射反射机制Java Reflection反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量，构造器，成员方法等等)，并能操作对象的属性及方法。反射在设计模式和框架底层都会用到加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象) ,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像面镜子，透过这个镜子看到类的结构，所以，形象的称之为: 反射Java反射机制原理示意图！！！![[外链图片转存失败,源站
复制链接

扫一扫