Java基础之反射
一、类加载器
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<T> 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
运行结果: