Java中的反射详解

键盘上的钢琴师_

已于 2022-03-23 11:27:03 修改

阅读量558

点赞数 2

分类专栏：行走的巨人文章标签： java

于 2022-03-23 11:23:36 首次发布

本文链接：https://blog.csdn.net/m0_46640386/article/details/123377911

版权

行走的巨人专栏收录该内容

9 篇文章 0 订阅

订阅专栏

反射机制

是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法；
这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

了解反射的概念以后，我们再了解一下Class类。

Class类对象

在Java语言中，一切皆是对象。而对象主要分为两种，一种是普通类创建的实例对象，一种是Class类对象。每个类运行时的类型信息就是通过Class对象表示的，这个对象包含了与类有关的信息。其实Java中的实例对象就是通过Class对象来创建的，Java使用Class对象执行其RTTI（运行时类型识别，Run-TimeType Identification），多态是基于RTTI实现的。

每一个类都有一个Class对象，每当编译一个新类就产生一个Class对象，更准确的来说，是被保存在一个同名的.class文件中。当程序中需要使用到这个类的时候(包括需要这个类的对象或引用这个类的静态变量)就通过类加载器将类加到内存中来。

Class类没有公共的构造方法，Class对象是在类加载的时候由Java虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象

获取Class对象的三种方式：

类名.class属性
对象名.getClass()方法
Class.forName(全类名)方法

Demo：

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);
        Class<Student> c2 = Student.class;
        System.out.println(c1 == c2);
        System.out.println("--------");
        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        System.out.println("--------");
        //使用Class类中的静态方法forName(String className)
        Class<?> c4 = Class.forName("com.sub.Student");
        System.out.println(c1 == c4);
    }
}
class Student{
    
    private String name;
    private String gender;
    
}

Class类获取构造方法对象的方法

方法名	说明
Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
Constructor getConstructor(Class<?>… parameterTypes)	返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class<?>…parameterTypes)	返回单个构造方法对象

Demo：

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


public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, IllegalAccessException, InvocationTargetException,InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.sub.Student");
        //Constructor<?>[] getConstructors() 返回一个包含 Constructor对象的数组，Constructor对象反映了由该 Class对象表示的类的所有公共构造函数
        //Constructor<?>[] cons = c.getConstructors();
        //Constructor<?>[] getDeclaredConstructors() 返回反映由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("--------");
        //Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
        //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
        Constructor<?> con = c.getConstructor();
        //Constructor提供了一个类的单个构造函数的信息和访问权限
        //T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
        Object obj = con.newInstance();
        System.out.println(obj);
        //Student s = new Student();
        //System.out.println(s);
    }
}

class Student {

   //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;

    //构造方法：一个私有，一个默认，两个公共
    public Student() {
    }

    private Student(String name) {
        this.name = name;
    }

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

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法：一个私有，四个公共
    private void function() {
        System.out.println("function");
    }

    public void method1() {
        System.out.println("method");
    }

    public void method2(String s) {
        System.out.println("method:" + s);
    }

    public String method3(String s, int i) {
        return s + "," + i;
    }

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

}

Constructor类用于创建对象的方法

方法名	说明
T newInstance(Object…initargs)	根据指定的构造方法创建对象
setAccessible(boolean ﬂag)	设置为true,表示取消访问检查（被private修饰的成员,不能直接使用的，如果用反射强行获取并使用,需要临时取消访问检查）

Demo:

public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, IllegalAccessException, InvocationTargetException,
            InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.sub.Student");
        //public Student(String name, int age, String address)
        //Constructor<T> getConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getConstructor(String.class, int.class,
                String.class);
        //基本数据类型也可以通过.class得到对应的Class类型
        //T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞" , 30, "西安");
        System.out.println(obj);
		
		/*//private Student(String name)
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getDeclaredConstructor(String.class);
        //暴力反射
        //public void setAccessible(boolean flag):值为true，取消访问检查
        con.setAccessible(true);
        Object obj = con.newInstance("林青霞");
        System.out.println(obj);*/
    }
}

class Student {
	//参照如上
   
}

Class类获取成员变量对象的方法

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象

Demo:反射获取成员变量并使用

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


public class ReflectDemo03 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, IllegalAccessException, InvocationTargetException,
            InstantiationException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("com.sub.Student");
        //Field[] getFields() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段
        //Field[] getDeclaredFields() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段
        //Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for(Field field : fields) {
            System.out.println(field);
        }
        System.out.println("--------");
        //Field getField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段
        //Field getDeclaredField(String name) 返回一个 Field对象，该对象反映由该Class对象表示的类或接口的指定声明字段
        Field addressField = c.getField("address");
        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        //obj.addressField = "西安";
        //Field提供有关类或接口的单个字段的信息和动态访问
        //void set(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值
        addressField.set(obj,"西安"); //给obj的成员变量addressField赋值为西安
        System.out.println(obj);
    }
}

class Student {
    //参照如上
}

Field类用于给成员变量赋值的方法

方法名	说明
void set(Object obj, Object value)	赋值
Object get(Object obj)	获取值

Demo:

public class ReflectDemo04 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, IllegalAccessException, InvocationTargetException,
            InstantiationException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("com.sub.Student");
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);
        //s.name = "林青霞";Field nameField = c.getField("name"); //NoSuchFieldException:
        Field nameField = c.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(obj, "林青霞");
        System.out.println(obj);
        //s.age = 30;
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,30);
        System.out.println(obj);
        //s.address = "西安";
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true);
        addressField.set(obj,"西安");
        System.out.println(obj);
	}
}

class Student {
    //参照如上
}

Class类获取成员方法对象的方法

方法名	说明
Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>…parameterTypes)	返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>…parameterTypes)	返回单个成员方法对象

Demo:

public class ReflectDemo05 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, IllegalAccessException, InvocationTargetException,
            InstantiationException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("com.sub.Student");
        //Method[] getMethods() 返回一个包含 方法对象的数组， 方法对象反映由该 Class对象表示的类或接口的所有公共方法，包括由类或接口声明的对象以及从超类和超级接口继承的类
        //Method[] getDeclaredMethods() 返回一个包含 方法对象的数组， 方法对象反映由Class对象表示的类或接口的所有声明方法，包括public，protected，default（package）访问和私有方法，但不包括继承方法
        //Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for(Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------");
        //Method getMethod(String name, Class<?>... parameterTypes) 返回一个 方法对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法
        //Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回一 个 方法对象，它反映此表示的类或接口的指定声明的方法 Class对象
        //public void method1()
        Method m = c.getMethod("method1");
        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        //obj.m();
        //在类或接口上提供有关单一方法的信息和访问权限
        //Object invoke(Object obj, Object... args) 在具有指定参数的指定对象上调用此方法对象表示的基础方法
        //Object：返回值类型
        //obj：调用方法的对象
        //args：方法需要的参数
        m.invoke(obj);
        //Student s = new Student();
        //s.method1();
    }
}

class Student {
    //参照如上
}

Method类用于执行方法的方法

Object invoke(Object obj, Object… args) 运行方法。

参数一: 用obj对象调用该方法
参数二: 调用方法的传递的参数(如果没有就不写)
返回值: 方法的返回值(如果没有就不写)

反射练习案列：

1、反射练习之越过泛型检查

案例需求：通过反射技术，向一个泛型为Integer的集合中添加一些字符串数据。

import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectTest01 {
    public static void main(String[] args) throws Exception {
        //创建集合
        ArrayList<Integer> array = new ArrayList<Integer>();
        //array.add(10);
        //array.add(20);
        //array.add("hello");
        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add", Object.class);
        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");
        System.out.println(array);
    }
}

2、运行配置文件中指定类的指定方法
案例需求： 通过反射运行配置文件中指定类的指定方法

import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectTest02 {
    public static void main(String[] args) throws Exception {
        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("myReflect\\class.txt");//配置文件相对路径
        prop.load(fr);
        fr.close();
        /*配置文件数据内容如下
        className=com.sub.Student
        methodName=study
        */
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");
        //通过反射来使用
        Class<?> c = Class.forName(className);//com.sub.Student
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        Method m = c.getMethod(methodName);//study
        m.invoke(obj);
    }
}