1 反射概述
Java反射(Reflection)是指在运行时检查、获取和操作类、方法、字段等结构的能力。通过反射,可以在运行时动态地创建对象、调用方法、访问字段等,而不需要在编译时知道类的具体信息。反射是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
下面是正常方式和反射方式:
常用的反射类:
- Class 类:代表一个类的元数据,可以获取类的名称、字段、方法等信息。
- Constructor 类:用于描述类的构造方法。
- Method 类:用于描述类的方法。
- Field 类:用于描述类的字段。
Java反射机制提供的功能:
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
2 Class类
Class 类是 Java 反射机制的核心,它用于表示一个 Java 类的元数据。每个 Java 类在运行时都有一个对应的 Class 对象,可以通过这个对象获取类的相关信息,如类的名称、父类、接口、字段、方法等。
Class 对象只能由系统建立对象, 一个加载的类在 JVM 中只会有一个Class实例,一个Class对象对应的是一个加载到JVM中的一个.class文件,每个类的实例都会记得自己是由哪个 Class 实例所生成。通过Class可以完整地得到一个类中的所有被加载的结构,Class类是Reflection的根源,针对任何你想动态加载、运行的类,唯有先获得相应的Class对象
Class类常用方法:
- static Class forName(String name):返回指定类名 name 的 Class 对象
- Object newInstance():调用缺省构造函数,返回该Class对象的一个实例
- getName():返回此Class对象所表示的实体(类、接口、数组类、基本类型 或void)名称
- Class getSuperclass():返回当前Class对象的父类的Class对象
- Class [ ] getInterfaces():获取当前Class对象的接口
- ClassLoader getClassLoader():返回该类的类加载器
- Constructor[] getConstructors():返回一个包含某些Constructor对象的数组
- Field[] getDeclaredFields():返回Field对象的一个数组
- Method getMethod(String name,Class … paramTypes):返回一个Method对象,此对象的形参类型为paramType
案例:通过反射获得类和实例.
User类
package kdx;
public class User {
private String name;
private int age;
public String address = "beijing";
public String school = "北京大学";
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
private User(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
", school='" + school + '\'' +
'}';
}
public void show(){
System.out.println("show");
}
public void show(String msg,int age){
System.out.println("show"+" "+msg+" "+age);
}
public void display(String msg){
System.out.println(msg);
}
}
测试
public class ReflectionTest {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("kdx.User");
Object bean = clazz.newInstance(); //调用类的无参构造函数
Constructor constructor = clazz.getConstructor(String.class,int.class);
Object bean1 = constructor.newInstance("kong",18);//调用类的有参构造函数
Method method = clazz.getMethod("show");
method.invoke(bean1);
System.out.println(bean1);
}
}
结果:
show
User{name='kong', age=18, address='beijing', school='北京大学'}
3 反射动态获取类的结构
3.1 类结构调用的安全检查
setAccessible:默认是false,表示进行安全检查,存在安全检查时,不能访问private,设置为true,表示可以访问。
例如:
Constructor<User> con = clazz.getDeclaredConstructor(String.class);
//能够使用私有的构造函数产生对象?
con.setAccessible(true);//设置为true,表示可以访问private
User uer1 = con.newInstance("xing");
System.out.println(uer1);
3.2 构造函数
方法:
- getConstructors:获取所有构造
- getConstructor(Class… args):获取指定的一个构造函数
- getDeclaredConstructor:获得构造函数,包括private的构造函数
- newInstance(Object… args):执行构造函数产生对象
案例:
@Test
public void test1() throws Exception {
Class clazz = Class.forName("kdx.User");
//获取所有构造函数(包括private)
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor.getName() + " " + Arrays.toString(constructor.getParameterTypes()));
}
//获取无参构造函数
Constructor con1 = clazz.getConstructor();
Object bean1 = con1.newInstance();
System.out.println(bean1);
//获取有参构造函数
Constructor<User> con2 = clazz.getConstructor(String.class, int.class);
User user = con2.newInstance("kong", 18);
System.out.println(user);
//不能得到私有的构造函数
Constructor<User> con3 = clazz.getDeclaredConstructor(String.class);
//默认是false,表示进行安全检查,存在安全检查时,不能访问private,设置为true,表示可以访问。
con3.setAccessible(true);
User uer1 = con3.newInstance("xing");
System.out.println(uer1);
}
结果:
kdx.User [class java.lang.String]
kdx.User [class java.lang.String, int]
kdx.User []
User{name='null', age=0, address='beijing', school='北京大学'}
User{name='kong', age=18, address='beijing', school='北京大学'}
User{name='xing', age=0, address='beijing', school='北京大学'}
3.3 成员变量
方法:
- getFields:获得范围内的所有变量(不包括private)
- getDeclaredFields:获得所有变量(包括private)
- getDeclaredField(String name):获得具体的变量(包括private)
- field.getName:获得变量的名字
- field.get(实例):得到变量值
- field.set(实例,变量值):设置变量的值
示例:
@Test
public void test2() throws Exception {
Class clazz = Class.forName("kdx.User");
Object bean = clazz.newInstance(); //调用无参构造函数产生对象
//Field[] fields = clazz.getFields();//得到所有权限范围内的变量(不包括private)
Field[] fields = clazz.getDeclaredFields();//得到所有权限范围内的变量(包括private)
for (Field field : fields) {
field.setAccessible(true);
System.out.println(field.getName() + "=" + field.get(bean));
}
//获得指定的field
Field field = clazz.getDeclaredField("name");
field.setAccessible(true);
field.set(bean, "kong");
System.out.println(field.get(bean));
System.out.println(bean);
}
结果:
name=null
age=0
address=beijing
school=北京大学
kong
User{name='kong', age=0, address='beijing', school='北京大学'}
3.4 成员方法
方法:
- getMethods:得到类的所有方法,包括父类的方法
- getDeclaredMethods:得到当前类的所有方法,包括private
- getMethod(方法名,方法参数列表…):得到指定的方法
- getDeclaredMethod:得到指定的私有方法
- method.invoke(对象实例,方法的参数值列表):调用方法
示例:
@Test
public void test3() throws Exception {
Class clazz = Class.forName("kdx.User");
Object bean = clazz.newInstance(); //调用无参构造函数产生对象
//Method[] methods = clazz.getMethods();//得到修饰符范围内的所有方法
Method[] methods = clazz.getDeclaredMethods();//得到所有方法(包括private)
for (Method method : methods) {
System.out.println(method.getName());
}
Method show = clazz.getMethod("show"); //得到具体方法
show.invoke(bean);
Method show2 = clazz.getMethod("show", String.class, int.class); //得到具体方法
show2.invoke(bean, "hello show", 24);
Method display = clazz.getDeclaredMethod("display", String.class); //得到具体方法
display.setAccessible(true);
display.invoke(bean, "hello display");
}
结果:
toString
getName
setName
display
show
show
getAge
setAge
show
show hello show 24
hello display
3.5 面试题
如何在不改变String内存地址的情况下,改变String的内容?
示例:
test1
@Test
public void test1(){
String s = new String("abc"); //堆里面产生s
String s1 = s;
s = "123";
String s2 = s;
System.out.println(s1.hashCode() + " " + s2.hashCode() );
System.out.println(s1 == s2);
}
结果:
96354 48690
false
内存分析:
test1 方法中,原始的 s 引用指向了新的字符串对象 “123”,s1指向String对象,而s2指向了新的字符串对象123。
test2
@Test
public void test2() throws Exception {
String s = new String("123"); //堆里面产生s
System.out.println(s);
String s1 = s;
Field vf = String.class.getDeclaredField("value");
vf.setAccessible(true);//可忽略final修饰符
char[] chars = {97, 98, 99};
vf.set(s, chars);
String s2 = s;
System.out.println(s1.hashCode() + " " + s2.hashCode() );
System.out.println(s1 == s2);
System.out.println(s);
}
结果:
123
96354 96354
true
abc
内存分析:
test2 方法中,使用了反射来改变 String 对象的内部字符数组,将其改为 “abc” 对应的字符数组。这会影响所有引用该字符数组的字符串,包括 s、s1 和 s2。因此,s1 和 s2 都指向了同一个对象,它们的 hashCode() 相同,并且 s1 == s2 为 true,因为它们指向同一个对象。