Java基础之反射
Java基础之反射
- 一、类加载器
- 1.类的加载
- 2.类的加载时机（进入内存）
- 3.类加载器
- 4.类加载器的组成
- 二、反射
- 1.Class类
- 2.通过反射获取构造方法并使用
- 三、反射练习
- 1.泛型擦除
- 2.反射通过配置文件运行功能的实现
一、类加载器
1.类的加载
- 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三个步骤来实现对这个类进行初始化。
- 加载
- 就是指将class文件读入内存，并为之建立一个Class对象。
- 任何类被使用时系统都会建立一个Class对象。
- 连接
- 验证：是否有正确的内部结构，并且和其他类协调一致。
- 准备：负责为类的静态成员分配内存，并设置默认的初始化值。
- 解析：将类的二进制数据中的符号引用替换为直接引用。
- 初始化
2.类的加载时机（进入内存）
- 直接使用java.exe命令来运行某个主类。
- 创建类的实例（new对象）。
- 使用类的静态变量，或者为静态变量赋值。
- 调用类的静态方法。
- 初始化某个类的子类，其父类先进入内存。
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
- 最先进入内存的类是Object类，并且最先执行的方法并不是main方法，二十Object类中的registerNatives()，将对象注册在操作系统上。
3.类加载器
- 负责将.class文件加载到内存中，并为之生成对应的Class对象。
4.类加载器的组成
- Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载（jre的lib目录下rt.jar）。 - Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载（ext文件夹下）。 - System ClassLoader 系统类加载器
负责在JVM启动时在加载来自java命令的class文件，以及第三方jar文件。
二、反射
1.Class类
- 获取Class对象的三种方式
- 通过Object类中的getClass()方法。
- 通过类名.class获取到字节码文件对象（任意数据类型都具备一个class静态属性）。
- 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName()即可）。字符串必须是包名加类名。
- 代码演示（假定有一个类Person，通过三种方法获取Person类的class文件对象）
package cn.mrzhang.demo1;
/**
* 获取一个类的class文件对象的三种方式：
* 1.对象获取
* 2.类名获取
* 3.Class类静态方法获取
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
//1.对象获取
Person person = new Person();
//调用Person类的父类方法getClass() 返回Person的class文件的对象
Class c1 = person.getClass();
//c表示Person类的class文件的文件对象，打印出带着包名的全类名
System.out.println(c1);
//2.类名获取
//每个类型，包括基本和引用，都会赋予这个类型一个静态的属性，属性名字叫class
Class c2 = Person.class;
System.out.println(c2);
System.out.println(c1==c2);
//3.Class静态方法获取
Class c3 = Class.forName("cn.mrzhang.demo1.Person");
System.out.println(c3);
System.out.println(c1==c3);
}
}
2.通过反射获取构造方法并使用
在反射集中中，把类中的成员（构造方法，成员方法，成员变量）都封装成了对应的类进行表示。其中，构造方法可以使用类Constructor表示。可通过Class类中提供的方法获取构造方法。
- 获取一个构造方法：
- public Constructor getConstructor()
- 获取多个构造方法：
- public Constructor[] getConstructors()
- 执行其public构造方法：
- 使用Constructor类中的newInstance()方法。
- 快捷创建对象实例的方法：
- 调用Class类中的newInstance()方法。
- 前提：被反射的类必须具有无参构造，无参构造必须为public。
- 获取所有public成员变量：
- 调用Class类的方法getFields()，返回值为Field[]，Field类为表述成员变量对象的类。
- 获取指定public成员变量：
- 调用Class类的方法getField(字符串类型的变量名)，返回值为Field。
- 赋值：public void set(Object obj, Object value)
- 获取值：public Object get(Object obj)
- 获取所有public成员方法：
- 调用Class类的方法getMethods()，返回值为Method[]，Method类为表述成员方法对象的类。
- 获取指定public成员方法：
- 调用Class类的方法getMethod(字符串类型的方法名，class … c)，返回值为Method。
- 执行其private构造方法，获取私有成员变量，执行私有成员方法（暴力私有）：
- 调用Constructor类的父类AccessibleObject的方法setAccessible（boolean b）方法，布尔值为true，则可以执行。值为true时，指示反射的对象在使用时取消Java语言的方法检查，则可以执行私有构造方法。
- getDeclaredConstructor(Class … c)
- getDeclaredField()
- getDeclaredMethod(“字符串类型成员方法名称”，方法参数列表的class文件对象)
- 注意事项：不推荐使用反射获取私有的构造方法并执行，因为其破坏了程序的封装性与安全性。
- 代码演示（反射获取Person类的所有构造方法与无参数构造方法）
package cn.mrzhang.demo1;
import java.lang.reflect.Constructor;
/**
* 通过反射获取class文件中的构造方法，运行构造方法
* 通过运行构造方法，从而创建对象
*
* 步骤：
* 1.获取class文件对象
* 2.从class文件对象中，获取需要的成员
*
* Constructor描述构造方法对象类
*/
public class ReflectDemo1 {
public static void main(String[] args) throws Exception {
Class c = Class.forName("cn.mrzhang.demo1.Person");
//使用class文件对象获取类中所有的构造方法
// Constructor[] getConstructors() 获取class文件对象中的所有public构造方法
Constructor[] cons = c.getConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
//获取一个指定的构造方法
Constructor constructor = c.getConstructor();
System.out.println(constructor);
//运行空参构造方法，Constructor类方法newInstance()运行获取到的构造方法
Object obj = constructor.newInstance();
System.out.println(obj.toString());
//通过强制转换为Person类对象,则可调用其变量和方法。
Person p = (Person)obj;
}
}
- 代码演示（反射获取Person类的指定构造方法并且执行）
package cn.mrzhang.demo1;
import java.lang.reflect.Constructor;
/**
* 通过反射，获取有参数构造方法并且执行
*/
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
//获取带有String，String，int参数的构造方法
//Constructor getConstructor ( Class ... parameterTypes)
//Class ... parameterTypes 传递要获取的构造方法的参数列表
Constructor<?> con = c1.getConstructor(String.class, String.class, int.class);
System.out.println(con);
//执行构造方法
//使用Constructor类中的newInstance(Object ... initargs)方法，括号内为传递的实际参数
Object obj = con.newInstance("小明", "男", 20);
System.out.println(obj);
}
}
- 代码演示（反射获取Person类构造方法并执行，简便方法）
package cn.mrzhang.demo1;
/**
* 反射获取构造方法并执行（快捷）
* 前提：
* 1.被反射的类必须具有无参构造
* 2.无参构造必须为public
*
* Class类中的方法：
* newInstance()
* 直接创建被反射的类的对象实例，
* 不需要使用Constructor类中的getConstructor()方法获取构造方法
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception{
Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
//调用方法newInstance()
Object obj = c1.newInstance();
System.out.println(obj);
}
}
- 代码演示（反射获取Person类的成员变量并修改值）
package cn.mrzhang.demo1;
import java.lang.reflect.Field;
/**
* 反射获取成员变量值，并修改值
* Class类中的方法：
* 1.getFields()，返回值为Field[]
* 获取所有成员变量，Field类为表述成员变量的类
* 2.getField(字符串类型的变量名)，返回值为Field
* 获取指定成员变量
* Field类中的方法：
* 1.void set(Object obj,Object value)
* 用来修改成员变量，前者为对象，后者为值
*/
public class ReflectDemo4 {
public static void main(String[] args) throws Exception{
Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
Object obj = c1.newInstance();
//获取所有成员变量
Field[] fields = c1.getFields();
for (Field f : fields){
System.out.println(f);
}
//获取指定成员变量
Field name = c1.getField("name");
System.out.println(name);
//修改成员变量值
name.set(obj,"小红");
System.out.println(obj);
}
}
- 代码演示（反射获取Person类的无参数成员方法并执行）
package cn.mrzhang.demo1;
import java.lang.reflect.Method;
/**
* 反射获取无参数成员方法并运行
* 步骤：
* 1.获取class对象中所有的public成员方法
* Method[] getMethods() 获取的是class文件中所有的成员方法，包括继承的方法
* Method类是描述成员方法的对象
* 2.获取class对象中指定的public成员方法
* Method getMethod("字符串类型的方法名"，参数列表)
* 3.执行，使用Method类中的方法，运行所获取的方法
* Object invoke(Object obj , Object ... o)
*/
public class ReflectDemo5 {
public static void main(String[] args) throws Exception{
Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
//创建类的对象
Object obj = c1.newInstance();
//获取所有成员方法
Method[] methods = c1.getMethods();
for (Method m : methods) {
System.out.println(m);
}
System.out.println("----------------------");
//获取指定成员方法
Method fun1 = c1.getMethod("fun1");
System.out.println(fun1);
//执行成员方法
fun1.invoke(obj);
}
}
- 代码演示（反射获取Person类的有参数成员方法并执行）
package cn.mrzhang.demo1;
import java.lang.reflect.Method;
/**
* 反射获取有参数成员方法并执行
*/
public class ReflectDemo6 {
public static void main(String[] args) throws Exception{
Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
//创建对象实例
Object obj = c1.newInstance();
//获取指定方法
Method setAge = c1.getMethod("setAge", int.class);
System.out.println(setAge);
//执行方法
Object o = setAge.invoke(obj, 20);
Person p = (Person)obj;
System.out.println(p.getAge());
}
}
三、反射练习
1.泛型擦除
- 定义集合类，泛型String，要求向集合中添加Integer类型。
- 集合类的泛型为String，向集合添加Integer类型数据会编译失败。
- 伪泛型：编译后的class文件是没有泛型的。
- 想法：绕过泛型，直接调用class文件中的add方法。
- 步骤：
- 获取ArrayList类的class文件对象。
- 获取ArrayList.class文件中的方法add()。
- 向其中添加字符串元素。
package cn.mrzhang.demo1;
import java.lang.reflect.Method;
import java.util.ArrayList;
/**
* 泛型擦除
* 定义集合类，泛型String
* 要求向集合中添加Integer类型
*/
public class Demo7 {
public static void main(String[] args) throws Exception {
ArrayList<String> list = new ArrayList<>();
list.add("abc");
list.add("def");
//获取ArrayList类的class文件对象
Class<? extends ArrayList> c1 = list.getClass();
//获取ArrayList.class文件中的方法add()
Method add = c1.getMethod("add",Object.class);
System.out.println(add);
//向其中添加字符串元素
add.invoke(list,1);
System.out.println(list);
}
}
2.反射通过配置文件运行功能的实现
- 调用某类的某个方法，不清楚哪个类的哪个方法。
- 通过配置文件实现此功能：
- 运行的类名与方法名，以键值对的形式写在文本中。
- 运行哪个类，读取配置文件即可。
- 实现步骤：
- 准备配置文件，键值对的形式。
- IO流读取配置文件 Reader。
- 将文件中的键值对存储到集合中Properties（集合中保存的键值对就是要运行的类名与方法）。
- 反射获取指定类的class文件对象。
- 通过class文件对象，获取指定的方法。
- 运行方法。
package cn.mrzhang.demo2;
//测试类1
public class Person {
public void eat(){
System.out.println("人在吃饭");
}
}
package cn.mrzhang.demo2;
//测试类2
public class Student {
public void study(){
System.out.println("学生在学习");
}
}
package cn.mrzhang.demo2;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* 调用3个类中一个类的方法
* 不清楚调用哪个类中的哪个方法，不能修改代码
*
* 通过配置文件实现此功能
* 运行的类名与方法名，以键值对的形式写在文本中
* 运行哪个类，读取配置文件即可
* 实现步骤：
* 1.准备配置文件，键值对的形式
* 2.IO流读取配置文件 Reader
* 3.将文件中的键值对存储到集合中Properties
* 集合中保存的键值对就是要运行的类名与方法名
* 4.反射获取指定类的class文件对象
* 5.通过class文件对象，获取指定的方法
* 6.运行方法
*/
public class TestDemo2 {
public static void main(String[] args) throws Exception {
//IO流读取配置文件
InputStream resourceAsStream = TestDemo2.class.getClassLoader().getResourceAsStream("config.properties");
//创建集合对象
Properties p = new Properties();
//调用方法load传递流对象
p.load(resourceAsStream);
//释放流对象
resourceAsStream.close();
//通过键获取值
String className = p.getProperty("className");
String methodName = p.getProperty("methodName");
//反射获取指定类的class文件对象
Class<?> c1 = Class.forName(className);
Object obj = c1.newInstance();
//反射获取指定的方法
Method method = c1.getMethod(methodName);
//执行方法
method.invoke(obj);
}
}
配置文件(config.properties)：
className=cn.mrzhang.demo2.Student
methodName=study
#className=cn.mrzhang.demo2.Person
#methodName=job
运行结果：
