java学习笔记（二十三）- 反射

反射机制

  • 反射机制（Java Refection）允许程序在执行期借助与Refection API取得任何类的内部信息（如：成员变量、构造器、成员方法等），并能直接操作对象的属性及方法

1、应用

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

相关的类

1
2
3
4
(1)java.lang.Class//代表一个类，Class对象表示某个类加载后再堆中的对象
(2)java.lang.reflect.Method//代表类的方法，Method对象表示某个类的方法
(3)java.lang.reflect.Field//代表类的成员变量，Filed对象表示某个类的成员变量
(4)java.lang.reflect.Constructor//代表类的构造方法，Constructor对象表示构造器

3、优点和缺点

  • 优点：

    • 可以动态的创建和使用对象(框架底层核心)，使用灵活

  • 缺点：

    • 使用反射基本是解释执行，对执行速度有影响

调用优化

  • 关闭访问检查：

    1
    .setAccessble(true)//点前面加Method、Filed、Constructor对象

  • 开启访问检查：

    1
    .setAccessble(false)//点前面加Method、Filed、Constructor对象，默认开启访问检查

Class类

基本介绍

  • Class类也是类，继承了Object类

  • Class类对象不是new出来的，而是系统创建的

  • 对于某个类的Class对象，在内存中只有一份，因为类只加载一次

  • 通过Class对象可以得到一个类的完整结构

  • Class对象存放在堆中

  • 类的字节码二进制数据，是放在方法区（或者称为类的元数据（包括方法代码、变量名、方法名、访问权限等）

    java程序在计算机中的三个阶段

应用

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
public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        //定义类名路径
        String classAllPath = "com.hzy.study.Car";
        //1. 获取到 Car类 对应的 Class对象
        //<?> 泛型通配符 表示不确定Java的类型
        Class<?> cls = Class.forName(classAllPath);
        //2. 输出 cls
        System.out.println(cls);//显示cls 对象，是哪个类的 Class对象 com.hzy.study.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);//car.toString
        //6. 通过反射获取属性 brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马
        //7. 通过反射给属性赋值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car));//奔驰
        //8. 获取到所有的属性(字段)
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName());//名称
        }
    }
}

获取Class对象

Class.forName

  • 前提：已知一个类的全类名，且该类在类的路径下，可通过Class类的静态方法forName()获取
  • 应用场景：多用于配置文件，读取类全路径，加载类
1
2
3
4
//1. Class.forName
String classAllPath = "com.hzy.study.Car";//通过读取配置文件获取
Class cls = Class.forName(classAllPath);
System.out.println(cls);

类名.Class

  • 前提：已知具体的类，通过类的Class获取，该方式最为安全可靠，程序性能最高
  • 应用场景：多用于参数传递
1
2
3
//2. 类名.class 多用于参数从传递
Class cls2 = Car.class;
System.out.println(cls2);

对象.getClass()

  • 前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
  • 应用场景：通过创建好的对象，获取Class对象
1
2
3
4
//3. 对象.getClass() 已知对象实例
Car car = new Car();
Class<? extends Car> cls3 = car.getClass();
System.out.println(cls3);

通过类加载器[4种]

1
2
3
4
5
6
7
8
9
//ClassLoader cl = 对象.getClass.getClassLoader();
//Class class4 = cl.loadClass("类的全类名");

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

基本数据类型

1
2
3
4
5
6
//Class cls = 基本数据类型.class
//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  自动装箱 自动拆箱

基本数据类型的包装类

1
2
3
4
5
//Class cls = 包装类.TYPE
//6. 基本数据类型对应的包装类 通过 .TYPE 得到 Class对象
Class<Integer> type1 = Integer.TYPE;
Class<Character> type2 = Character.TYPE;
System.out.println(type1);

拥有Class对象的类型

1
2
3
4
5
6
7
8
9
10
Class<String> cls = String.class;//外部类，成员内部类，静态内部类，局部内部类，匿名内部类
Class<Serializable> cls2 = Serializable.class;//interface接口
Class<Integer[]> cls3 = Integer[].class;//数组
Class<float[][]> cls4 = float[][].class;//二维数组
Class<Deprecated> cls5 = Deprecated.class;//annotation注解
//enum枚举
Class<Thread.State> cls6 = Thread.State.class;//线程里面的State
Class<Float> cls7 = float.class;//基本数据类型
Class<Void> cls8 = void.class;//返回类型
Class<Class> cls9 = Class.class;

类加载

静态加载

  • 编译时加载相关的类，如果没有就报错，依赖性强
  • 场景：
    • 当创建对象时(new)
    • 当子类被夹在时，父类也加载
    • 调用类中的静态成员

动态加载

  • 运行时加载需要的类，如果不运行时不用该类，即使不存在该类也不报错，降低了依赖性
  • 场景：反射

类加载过程

类加载过程

加载阶段
  • 将字节码从不同的数据源(class文件、jar包、网络)转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象
连接阶段
验证
  • 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
  • 包括：问价格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证
  • 缩短虚拟机类加载时间：-Xverify:none 参数来关闭大部分的类验证措施
准备
  • 对静态变量分配内存并初始化（对应数据类型的默认初始值：如0、0L、null、false等），这些变量所使用的的内存都将在方法区中进行分配
解析
  • 虚拟机将常量池内的符号引用替换为直接引用的过程
初始化（initialization)
  • 到初始化阶段,才真正开始执行类中定义的Java程序代码，此阶段是执行(0)方法的过程
  • ()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并进行合并
  • 虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕

反射获取类结构信息

java.lang.Class类

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@Test
    public void api_01() throws ClassNotFoundException {
        Class<?> personCls = Class.forName("com.hzy.study.reflection.Person");
        //1. getName 获取全类名
        System.out.println(personCls.getName());//com.hzy.study.reflection.Person
        //2. getSimpleName 获取简单类名
        System.out.println(personCls.getSimpleName());//Person
        //3. getFields 获取所有public 修饰的属性 包含本类以及父类
        Field[] fields = personCls.getFields();
        for (Field field : fields) {
            System.out.println("本类以及父类public 修饰的属性 " + field.getName());
        }
        //4. getDeclaredFields 获取本类中所有的属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有的属性=" + declaredField.getName());
        }
        //5. getMethods 获取所有public 修饰的方法 包含本类及父类的
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println("本类及父类所有public 修饰的方法=" + method.getName());
        }
        //6. getDeclaredMethods 获取本类中所有的方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有的方法" + declaredMethod.getName());
        }
        //7. getConstructors 获取所有public 修饰的构造器 本类
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类所有public 修饰的构造器" + constructor.getName());
        }
        //8. getDeclaredConstructors 获取本类所有的构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类所有的构造器=" + declaredConstructor.getName());
        }
        //9. getPackage 获取包信息
        System.out.println(personCls.getPackage());//com.hzy.study.reflection
        //10. getSuperClass 返回父类信息
        Class<?> superclass = personCls.getSuperclass();
        System.out.println("父类信息=" + superclass.getName());//A
        //11. getInterfaces 返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息=" + interfaces);
        }
        //12. getAnnotations 返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息=" + annotation);
        }
    }

java.lang.reflect.Field类

1
2
3
4
getModifiers//以int形式返回修饰符
//默认修饰符 是0, public 是 1, private 是 2, protected 是 4, static 是 8, final 是 16
getType//以Class形式返回类型
getName//返回属性名
1
2
3
4
5
6
7
8
9
Class<?> personCls = Class.forName("com.hzy.study.reflection.Person");
        //4. getDeclaredFields 获取本类中所有的属性
        //说明 默认修饰是 0 ,public 是 1 , private 是2, protected 是 4, static 是 8
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有的属性=" + declaredField.getName()
            + " 该属性的修饰值=" + declaredField.getModifiers()
            + " 该属性的类型=" + declaredField.getType());
        }

java.lang.reflect.Method类

1
2
3
4
5
getModifiers//以int形式返回修饰符
//默认修饰符 是0, public 是 1, private 是 2, protected 是 4, static 是 8, final 是 16
getReturnType//以Class形式获取返回类型
getName//返回方法名
getParameterTypes//以Class[]返回参数类型数组
1
2
3
4
5
6
7
8
9
10
11
12
//6. getDeclaredMethods 获取本类中所有的方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有的方法" + declaredMethod.getName() +
            " 该方法的访问修饰符的值=" + declaredMethod.getModifiers()
            + " 该方法的返回类型=" + declaredMethod.getReturnType());

            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println(" 该方法的返回参数类型=" + parameterType);
            }
        }

java.lang.reflect.Constructor类

1
2
3
getModifiers//以int形式返回修饰符
getName//返回构造器名(全类名)
getParameterTypes//以Class[]返回参数类型数组
1
2
3
4
5
6
7
8
9
10
//8. getDeclaredConstructors 获取本类所有的构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类所有的构造器=" + declaredConstructor.getName());

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

反射创建对象

通过类中public修饰的无参构造器

1
2
3
4
5
//1. 先获取到User类的Class对象
Class<?> userClass = Class.forName("com.hzy.study.reflection.User");
//2. 通过public 的无参构造器创建实例
Object user1 = userClass.newInstance();
System.out.println(user1);

通过类中public修饰的有参构造器

1
2
3
4
5
6
//3. 通过public 的有参构造器创建实例
//3.1 获取构造器
Constructor<?> constructor = userClass.getConstructor(String.class);
//3.2 创建对象
Object user2 = constructor.newInstance("执笔");
System.out.println(user2);

通过非public修饰的有参构造器

1
2
3
4
5
6
//4. 通过非public 的有参构造器创建实例
Constructor<?> declaredConstructor = 
    userClass.getDeclaredConstructor(int.class, String.class);
declaredConstructor.setAccessible(true);//暴破  关闭检查
Object user3 = declaredConstructor.newInstance(20, "执笔");
System.out.println(user3);

反射访问类中成员

访问属性

1
2
3
4
5
6
7
//根据属性名获取Field对象
Field f = clazz对象.getDeclaredField(属性名);
//暴破
f.setAccessible(true);
//访问
f.set(o,值);//如果是静态属性，o 可以写成null
System.out.println(f.get(o));//如果是静态属性，o 可以写成null
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//1. 获取Student 对应的Class对象
Class<?> stuClass = Class.forName("com.hzy.study.reflection.Student");
//2. 创建对象
Object o = stuClass.newInstance();
System.out.println(o.getClass());//Student
//3. 使用反射得到 age
Field age = stuClass.getField("age");
age.set(o, 20);//通过反射来获取属性
System.out.println(age.get(o));
System.out.println(o);
//4. 使用反射得到name
Field name = stuClass.getDeclaredField("name");
name.setAccessible(true);//暴破
name.set(o,"执笔");
System.out.println(name.get(o));
name.set(null,"执笔~");//静态属性 与类相关
System.out.println(name.get(null));

访问方法

1
2
3
4
5
6
7
8
//根据方法名和参数列表获取Method方法对象:
Method m =clazz.getDeclaredMethod(方法名，XX.class);
//获取对象
Object o = clazz.newlnstance();
//暴破
m.setAccessible(true);
//访问:
Object returnValue = m.invoke(o,实参列表);//如果是静态方法，则invoke的参数o，可以写成null
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//1. 获取Boos的Class对象
Class<?> boosClass = Class.forName("com.hzy.study.reflection.Boss");
//2. 创建对象
Object o = boosClass.newInstance();
//3. 调用public hi() 方法
Method hi = boosClass.getDeclaredMethod("hi", String.class);
hi.invoke(o,"执笔");

//4. 调用private static say方法
Method say = boosClass.getDeclaredMethod("say", int.class, String.class, char.class);
say.setAccessible(true);//因为方法私有 需要暴破
System.out.println(say.invoke(o, 100,"张三",'男'));
System.out.println(say.invoke(null, 200, "李四",'男'));//因为say方法时static 可以传入null

//5. 反射中 如果方法有返回值 统一返回Object 但运行类型与方法定义的返回类型一致
Object reVal = say.invoke(null, 300, "王五", '男');
System.out.println("reVal 的运行类型= " + reVal.getClass());//String