Java基础-反射

反射机制

允许程序在执行期借助于Reflection API取得任何类的内部信息（比如成员变量、构造器、成员方法等等），并能操作对象的属性及方法，反射大量用于设计模式与框架底层
加载完类之后，在堆中产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息，通过这个对象得到类的结构。这个类就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射
作用
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时得到任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
- 生成动态代理
相关的主要类
- java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constrctor:代表类的构造方法
优缺点
- 优势：可以动态创建和使用对象（也就是框架底层核心），使用灵活
- 缺点：使用反射基本是解释执行，对执行速度有影响
优化
- Method、Field、Constructor对象都有setAccessible)_方法
- setAccessible作用时启动和禁用访问安全检查的开关
- 参数为true表示对象在使用时取消访问检查，提高效率

Class类

基本概念
- Class也是类，因此也继承Object类
- Class类对象不是new出来的，而是系统创建的
- 对于某个类的Class类对象，在内存中只有一份，类只加载一次（通过底层代码实现，同时还开启了线程锁）
- 每个类的实例都会记得自己是由哪个Class实例所生成
- 通过Class可以完整地得到一个类的完整结构，通过一系列的API
- Class对象是存放在堆的
- 类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码、变量名、方法名、访问权限等等）
常用方法
- static Class forName(String name) 返回指定类名name的Class对象
- Object newInstance() 调用缺省的构造函数，返回该Class对象的一个实例
- getName返回Class对象所表示的实体（类、接口、数组类、基础类型等）名称
- class getSiperClass()返回当前Class对象的父类和Class对象
- Class[] getInterfaces()获取当前Class对象的接口
- ClassLoader getClassLoader()返回该类的类加载器
- Class getSuperclass()返回表示此Class所表示的实体的超类的Class
- Constructor[] getConstructors()返回一个包含某些Constructor对象的数组
- Field[] getDeclaredFields()返回Field对象的数据
- Method getMethod（String name，Class。。。paramTypes）返回一个Method对象，此对象的形参为paramType
获取Class对象方式
- 代码阶段/编译阶段（用于配置文件，读取全路径）：Class.forName
- 加载阶段（多用于参数传递，比如通过反射得到对应的构造器对象）：类.class
- 运行阶段（通过已知的某个实例，来获取Class对象）：对象.getClass()
- 类加载器得到Class对象：ClassLoader cl = 对象.getClass().getClassLoader(); Class class4 = cl.loadClass(“类的全路径”)；
- 基本数据（int，char...）：Class cls = 基本数据类型.class
- 基本数据类型对应的包装类，可以通过.type得到Class类对象：Class cls = 包装类.TYPE
拥有Class对象的类型
- 外部类、内部类
- 接口
- 枚举
- 数组
- 注解
- 基本数据类型
- void

类加载

基本概念：反射机制是实现动态语言的关键，也就是通过反射实现类动态加载
- 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
- 动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖
类加载的时机
- 创建对象时（new）--静态加载
- 当子类被加载时--静态加载
- 调用类中的静态成员时--静态加载
- 通过反射（Class.forName（“com.test.cat”））--动态加载
示意图

加载阶段：JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、jar包、网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象
连接阶段-验证
- 为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
- 包括：文件格式验证（是否以魔数oxcafebabe开头）、元数据验证、字节码验证和符号引用验证
- 可以考虑是使用 -Xverify：none 参数来关闭大部分类验证措施，缩短虚拟机加载的时间

连接阶段-准备

JVM会在此阶段对静态变量，分配内存并默认初始化（0、0L、null、false等）。这些变量所属用的内存都将在方法区进行分配

//n1是实例属性，准备阶段不会分配内存
public int n1 =10;
//n2是静态属性，分配内存，同时初始化为0（20是等初始化阶段才赋值）
public static int n2 = 20;
//n3是常量，分配固定内存，且直接赋值30
public static final int n3=30;

链接阶段-解析
- 虚拟机将常量池内的符号引用替换为直接引用的过程（代码没有编译之前只是用变量名来表示引用，解析后，变成真正的内存地址来引用）
初始化
- 真正开始执行类中定义的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，public1，private2，protected4，static8，final16；组合修饰的话返回和的数字：public static 9）
- getType：以Class形似返回类型
- getName：返回属性名
java.lang.reflect.Method
- getModifiers:以int形式返回修饰符（默认修饰符0，public1，private2，protected4，static8，final16；组合修饰的话返回和的数字：public static 9）
- getReturnType:以Class形式获取返回类型
- getName：返回方法名
- getParmeterTypes：以Class[]返回参数类型数组
java.lang.reflect.Constructor
- getModifiers:以int形式返回修饰符（默认修饰符0，public1，private2，protected4，static8，final16；组合修饰的话返回和的数字：public static 9）
- getName:返回构造器名（全类名）
- getParameterTypes：以Class[]返回参数类型数组

演示代码

/**
 * 演示通过反射机制创建实例
 */
public class ReflecCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        //1. 先获取到User类的Class对象
        Class<?> userClass = Class.forName("com.hspedu.reflection.User");
        //2. 通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        //3. 通过public的有参构造器创建实例
        /*
            constructor 对象就是
            public User(String name) {//public的有参构造器
                this.name = name;
            }
         */
        //3.1 先得到对应构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        //3.2 创建实例，并传入实参
        Object hsp = constructor.newInstance("hsp");
        System.out.println("hsp=" + hsp);
        //4. 通过非public的有参构造器创建实例
        //4.1 得到private的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
        //4.2 创建实例
        //暴破【暴力破解】 , 使用反射可以访问private构造器/方法/属性, 反射面前，都是纸老虎
        constructor1.setAccessible(true);
        Object user2 = constructor1.newInstance(100, "张三丰");
        System.out.println("user2=" + user2);
    }
}

class User { //User类
    private int age = 10;
    private String name = "HSPJY";

    public User() {//无参 public
    }

    public User(String name) {//public的有参构造器
        this.name = name;
    }

    private User(int age, String name) {//private 有参构造器
        this.age = age;
        this.name = name;
    }

    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

/**
 * 演示反射操作属性
 */
public class ReflecAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

        //1. 得到Student类对应的 Class对象
        Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();//o 的运行类型就是Student
        System.out.println(o.getClass());//Student
        //3. 使用反射得到age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88);//通过反射来操作属性
        System.out.println(o);//
        System.out.println(age.get(o));//返回age属性的值

        //4. 使用反射操作name 属性
        Field name = stuClass.getDeclaredField("name");
        //对name 进行暴破, 可以操作private 属性
        name.setAccessible(true);
        //name.set(o, "老韩");
        name.set(null, "老韩~");//因为name是static属性，因此 o 也可以写出null
        System.out.println(o);
        System.out.println(name.get(o)); //获取属性值
        System.out.println(name.get(null));//获取属性值, 要求name是static

    }
}

class Student {//类
    public int age;
    private static String name;

    public Student() {//构造器
    }

    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
}

/**
 * 演示通过反射调用方法
 */
public class ReflecAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        //1. 得到Boss类对应的Class对象
        Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用public的hi方法
        //Method hi = bossCls.getMethod("hi", String.class);//OK
        //3.1 得到hi方法对象
        Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
        //3.2 调用
        hi.invoke(o, "韩顺平教育~");

        //4. 调用private static 方法
        //4.1 得到 say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2 因为say方法是private, 所以需要暴破，原理和前面讲的构造器和属性一样
        say.setAccessible(true);
        System.out.println(say.invoke(o, 100, "张三", '男'));
        //4.3 因为say方法是static的，还可以这样调用 ，可以传入null
        System.out.println(say.invoke(null, 200, "李四", '女'));

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


        //在演示一个返回的案例
        Method m1 = bossCls.getDeclaredMethod("m1");
        Object reVal2 = m1.invoke(o);
        System.out.println("reVal2的运行类型=" + reVal2.getClass());//Monster


    }
}

class Monster {}
class Boss {//类
    public int age;
    private static String name;

    public Boss() {//构造器
    }

    public Monster m1() {
        return new Monster();
    }

    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }

    public void hi(String s) {//普通public方法
        System.out.println("hi " + s);
    }
}

posted @ 2022-03-14 22:45 邵泽龙阅读(65) 评论(0) 收藏举报

刷新页面返回顶部

泽龙的学习笔记

Java基础-反射

Java基础-反射

反射机制

Class类

类加载

通过反射获取类结构信息

演示代码

公告