JavaSE自学笔记专题_Real（反射机制Reflection）

本文链接：https://blog.youkuaiyun.com/weixin_46076729/article/details/123545671

JavaSE自学笔记专题_Real（反射机制Reflection）

【韩顺平讲Java】Java反射专题 -反射反射机制类加载 reflection Class 类结构等

一、反射机制概述

1、反射机制允许程序在执行的时候借助于ReflectionAPI获取任何类的内部信息（比如成员变量、构造器、成员方法等），并能操作对象的属性以及方法，反射在设计模式和框架底层都会用到。
2、加载完类之后，在队中就会产生一个Class类的对象（一个类只有一个Class对象），这个对象包括了类的完成结构信息，通过这个对象得到类的结构，这个对象就像一个镜子，透过这个镜子看到类的结构，所以形象的称之为：反射。

在这里插入图片描述
3、反射机制可以完成
（1）在运行的时候判断任意一个对象所属的类；
（2）在运行的时候构造任意一个类的对象；
（3）在运行的时候得到任意一个类所具有的成员变量和方法；
（4）在运行的时候调用任意对象的成员变量和方法
（5）生成动态代理

4、反射相关的主要类
（1）java.lang.Class表示一个类，Class对象表示某个类加载后在队中的对象。
（2）java.lang.reflect.Method代表类的方法，Method对象表示某个类的方法。
（3）java.lang.reflect.Field代表类的成员变量，Field对象表示某个类的成员变量
（4）java.lang.reflect.Constructor，达标类的构造方法。

import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;


//反射的引例：利用反射俩创建一个类
@SuppressWarnings({"all"})
public class Test41 {
    public static void main(String[] args) throws Exception{
        //1、使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\com\\RefkectionStudy\\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();
        String methodName = properties.get("method").toString();
        System.out.println(classfullpath);
        System.out.println(methodName);
        //2、利用反射机制
        //（1）加载类， 返回Class类型的对象class
        Class cls = Class.forName(classfullpath);
        //（2）通过cls得到你加载的类
        Object obj = cls.getDeclaredConstructor().newInstance();
        //（3）通过cls得到加载的类的方法对象
        Method method = cls.getMethod(methodName);
        //（4）通过方法对象来实现调用方法
        method.invoke(obj);

        //得到name属性
        //getField()方法不能嗲用私有属性
        Field nameField = cls.getField("age");
        System.out.println(nameField.get(obj));

        //得到构造方法
        Constructor constructor = cls.getConstructor(); //得到无参构造器
        System.out.println(constructor);
        constructor = cls.getConstructor(String.class);
        System.out.println(constructor);
    }
}

二、反射的优缺点

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

三、Class类的特点

1、Class也是类，因此也继承了Object类；
2、Class类对象不是new出来的，而是系统创建的；
3、对于某个类的CLass类对象，在内存中只有一个，因此类只加载一次；
4、每个类的实例都会记得自己是由那个Class实例所生成的；
5、通过Class对象可以完整的得到一个类的完整结构，通过一系列API可以进行调用；
6、Class对象是存放在堆中的；
7、类的字节二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码、变量名、方法名、访问权限等）

public class Student01 {
    public String Name;
    public int Age;
    public int ID;
    public String School;

    public Student01(String name, int age, int ID, String school) {
        Name = name;
        Age = age;
        this.ID = ID;
        School = school;
    }

    public Student01(){
        System.out.println("学生类");
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    public String getSchool() {
        return School;
    }

    public void setSchool(String school) {
        School = school;
    }

    @Override
    public String toString() {
        return "Student01{" +
                "Name='" + Name + '\'' +
                ", Age=" + Age +
                ", ID=" + ID +
                ", School='" + School + '\'' +
                '}';
    }

    public void Study() {
        System.out.println(Name + "在学习");
    }

    public void GoToSchool(){
        System.out.println(Name + "去" + School + "上学");
    }
}


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

public class Test43 {
    public static void main(String[] args) throws Exception{
        String classFullPath = "com.ReflectionStudy.Student01";
        //获取Class对象
        Class<?> cls = Class.forName(classFullPath);
        //输出cls
        System.out.println(cls);
        System.out.println(cls.getClass());

        System.out.println(cls.getName());
        System.out.println(cls.getPackage().getName());

        Object student = cls.getDeclaredConstructor().newInstance();

        Field nameField = cls.getField("Name");
        System.out.println(nameField);
        nameField.set(student, "Tom");
        System.out.println(nameField.get(student));

        Method method = cls.getMethod("Study");
        System.out.println(method);
        method.invoke(student);

        Constructor constructor = cls.getConstructor(String.class, int.class, int.class, String.class);
        System.out.println(constructor);
        Object obj = constructor.newInstance("Mary", 21, 120101225, "NJUST");
        Student01 stu = (Student01) obj;
        System.out.println(stu.getName());
        System.out.println(stu.getAge());
        System.out.println(stu.getSchool());
        System.out.println(stu.getID());
        stu.GoToSchool();
    }
}

三、获取Class类对象的不同方式

**1、前提：**已知一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException;
实例：Class cls1 = Class.forName(“java.lang.cat”);
**应用场景：**多用于配置文件，读取类全部路径，加载类。

**2、前提：**若已经知道具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高;
实例：Class cls2 = Cat.class;
**应用场景：**多用于参数传递，比如通过反射得到对应的构造器对象。

**3、前提：**已经知道某个类的实例化对象，调用该实例的getClass()方法获取Class对象；
实例：Class cls3 = 对象.getClass(); //运行类型
**应用场景：**通过创建好的对象，获取Class对象

4、其他方式
ClassLoader cl = 对象.getClass().getClassLoader();
Class cls4 = cl.loadClass(“类的全类名”);

5、基本数据类型（int, char, boolean, float, double, byte, long, short）按如下方式得到Class类的对象
Class cls = 基本数据类型.class;

        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;

        System.out.println(integerClass);

6、基本数据类型对应的包装类，可以通过.TYPE得到Class类对象
Class cls = 包装类.TYPE;

        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1);

哪些类型有Class对象

1、外部类，成员内部类，静态内部类，局部内部类，匿名内部类
2、Interface：接口
3、数组
4、enum：枚举
5、annotation：注解
6、基本数据类型
7、void

四、类加载

1、动态加载与静态加载：反射机制是java实现动态语言的关键，也就是通过反射实现类的动态加载。
（1）静态加载：编译的时候加载相关的类，如果没有则会报错，依赖性太强；
（2）动态加载：运行的时候才会加载需要的类，如果运行的时候不用该类，即使不存在该类，也不会报错，降低了依赖性。

2、类加载的时机：
（1）当创建对象的时候（new）//静态加载
（2）当子类被加载的时候，父类也加载 //静态加载
（3）调用类中的静态成员时 //静态加载
（4）通过反射 //动态加载

在这里插入图片描述

类加载的过程：

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

五、获取类的结构信息

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

//通过反射获得类的结构信息
public class Test44 {
    public static void main(String[] args) throws ClassNotFoundException {
        Test44 test44 = new Test44();
        test44.api_01();
         test44.api_02();
    }

    //第一组方法
    public void api_01() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.ReflectionStudy.Person");
        //getName 获取全类名
        System.out.println(personCls.getName()); //com.ReflectionStudy.Person
        //获取简单类名
        System.out.println(personCls.getSimpleName()); //Person
        //获取所有public修饰的属性，包含奔雷以及父类的属性
        Field[] fields = personCls.getFields();
        for(Field field:fields){ //
            System.out.println(field.getName());
        }//name hobby
        //获取奔雷的所有属性
        /*
        name
        age
        job
        sal
         */
        fields = personCls.getDeclaredFields();
        for(Field field : fields){ //
            System.out.println(field.getName());
        }
        //获得所有的public修饰的方法，包含本类的父类的public方法
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        //获得所有的方法
        methods = personCls.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        //获取public修饰的构造器 不包括父类构造器
        Constructor[] constructors = personCls.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName());
        }
        //获取所有的构造器
        constructors = personCls.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName());
        }
        //获得以package形式返回的包信息
        System.out.println(personCls.getPackage());
        //获得以Class形式返回父类信息
        System.out.println(personCls.getSuperclass());
        //以Class[]形式返回类实现的接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class<?> anInterface : interfaces){
            System.out.println(anInterface.getName());
        }
        //以Annotation[]形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
        //第二组方法
    public void api_02() throws ClassNotFoundException {
        Class<?> personCls = Class.forName("com.ReflectionStudy.Person");
        //获取本类中的所有属性
        //规定：默认修饰符是0， public：1，private：2，protected：4，static：8，final：16
        //如果是多个修饰符，则返回相加之后的值
        Field[] fields = personCls.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getModifiers());
            System.out.println(field.getType());
        }
        //获得返回值类型
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println("该方法的返回值类型是"+method.getReturnType());
            Class<?>[] parameterTypes = method.getParameterTypes();
            for(Class<?> cls : parameterTypes){
                System.out.println("该方法的形参类型是"+cls.getName());
            }
        }

    }
}
class A{
    public String hobby;
}
interface B{
    void fun();
}

@Deprecated
class Person extends A implements B{
    //属性
    public String name;
    protected  int age;
    String job;
    private double sal;
    //方法
    public void m1(int num){

    }

    protected String m2(){
        return null;
    }
    void m3(){

    }
    private double m4(){
        return 0.0;
    }

    @Override
    public void fun() {
        System.out.println("hello");
    }
}

六、通过反射创建对象

1、方式一：调用类中的public修饰的无参构造器
2、方式二：调用类中指定的构造器
3、Class类相关方法
newInstance：调用类中的无参构造器，获取对应类的对象
getConstructor(Class…clazz)：根据参数列表，获取对应的public构造器对象
getDecalaredConstructor(Class…clazz)：根据参数列表，获取对应的所有构造器对象
4、Constructor类相关方法
setAccessible：爆破
newInstance(Object…obj)：调用构造器

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //获取UserTest类的Class对象
        Class<?> userTestCls = Class.forName("com.ReflectionStudy.UserTest");
        //通过public 的无参构造器创建实例
        Object obj = userTestCls.newInstance();
        System.out.println(obj);

        //通过public的有参构造器创建实例
        Constructor constructor = userTestCls.getConstructor(String.class);
        Object obj1 = constructor.newInstance("Tom");
        System.out.println(obj1);
        //通过非public的有参构造器创建实例
        //爆破【暴力破解】，使用反射可以访问private的构造器、方法、属性。
        Constructor constructor1 = userTestCls.getDeclaredConstructor(int.class, String.class);
        constructor1.setAccessible(true);
        obj = constructor1.newInstance(12, "Mary");
        System.out.println(obj);
    }
}

class UserTest{
    private int age = 10;
    private String name = "Jack";

    public UserTest(String name) {
        this.name = name;
    }

    public UserTest() {
    }

    private UserTest(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "UserTest{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

七、使用爆破获得私有的对象属性

import java.lang.reflect.Field;

public class Test45 {
    public static void main(String[] args) throws Exception{
        //获得StudentTest类的class对象
        Class<?> studentCls = Class.forName("com.ReflectionStudy.StudentTest");
        Object obj = studentCls.getConstructor().newInstance();
        Field age = studentCls.getField("age");
        age.set(obj, 12);
        System.out.println(obj);
        System.out.println(age.get(obj));

        //爆破获得私有属性name
        Field name = studentCls.getDeclaredField("name");
        name.setAccessible(true);
        //name.set(obj, "Todd");
        name.set(null, "Todd"); //因为name时静态的，所以obj可以换成null
        
        System.out.println(obj);
        System.out.println(name.get(obj));
    }
}


class StudentTest{
    public int age = 10;
    private static String name = "Jhon";

    public StudentTest() {
    }

    @Override
    public String toString() {
        return "StudentTest{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

八、通过反射访问类中的方法

1、通过方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名, xx.class); //得到本类的所有方法
2、获取对象：Object o = clazz.newinstance();

3、爆破：m.setAccessible(true);
4、访问：Object returnValue = m.invoke(o, 实参列表); //o就是对象
5、注意：如果是静态方法，则invoke的参数o，可以直接换成null。

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

public class Test45 {
    public static void main(String[] args) throws Exception{
        //获得本类的方法
        Class<?> stuCls = Class.forName("com.ReflectionStudy.StudentTest");
        Constructor constructor2 = stuCls.getConstructor();
        Object obj2 = constructor2.newInstance();
        //Method method1 = obj2.getClass().getMethod("fun1", int.class, int.class);
        Method method1 = stuCls.getMethod("fun1", int.class, int.class);
        Object num = method1.invoke(obj2, 23, 23);
        System.out.println(num);

        //method1 = obj2.getClass().getDeclaredMethod("fun2");
        method1 = stuCls.getDeclaredMethod("fun2");
        method1.setAccessible(true);
        method1.invoke(obj2);
        //method1 = obj2.getClass().getDeclaredMethod("fun3");
        method1 = stuCls.getDeclaredMethod("fun3");
        method1.invoke(null);
    }
}


class StudentTest{
    public int age = 10;
    private static String name = "Jhon";

    public StudentTest() {
    }

    public int fun1(int a, int b){
        System.out.println(a+b);
        return a+b;
    }

    private void fun2(){
        System.out.println("私有方法的调用");
    }

    public static void fun3(){
        System.out.println("静态方法的调用！！！！");
    }

    @Override
    public String toString() {
        return "StudentTest{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}