1 反射概述
Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
加载完类之后, 在堆内存的方法区中就产生了一个Class类型的对象( 一个类只有一个Class对象) , 这个对象就包含了完整的类的结构信息。 我们可以通过这个对象看到类的结构。 这个对象就像一面镜子, 透过这个镜子看到类的结构, 所以, 我们形象的称之为: 反射。
- Java反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
- 反射主要API
- java.lang.Class:代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造器
- …
2 Class类和实例
在Object类中定义了以下的方法,此方法将被所有子类继承:public final Class getClass()以上的方法返回值的类型是一个Class类,此类是Java反射的源头,实际上所谓反射从程序的运行结果来看也很好理解,即:可以通过对象反射求出类的名称。
Class类:
- 对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言, JRE 都为其保留一个不变的Class 类型的对象。一个 Class对象包含了特定某个结构(class/interface/enum/annotation/primitivetype/void/[])的有关信息。
- Class本身也是一个类
- Class 对象只能由系统建立对象
- 一个加载的类在 JVM 中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源,针对任何你想动态加载、运行的类,唯有先获得相应的Class对象
Class类常用方法
- 获取Class类实例的方法:
- 前提: 若已知具体的类,通过类的class属性获取, 该方法最为安全可靠,程序性能最高。 Class clazz =String.class;
- 前提: 已知某个类的实例,调用该实例的getClass()方法获取Class对象。 Class clazz =“www.baidu.com”.getClass();
- 前提: 已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException。 Class clazz =
Class.forName(“java.lang.String”); - 其他方式(不做要求)
案例:通过反射获得类和实例
public static void main(String[] args) throws Exception {
// //正常使用
// User user = new User();
// user.show();
//反射使用
Class clazz = Class.forName("vo.User");
// Object bean = clazz.newInstance(); //调用类的默认构造函数
Constructor constructor = clazz.getConstructor(String.class, int.class);
Object bean = constructor.newInstance("mickey", 15); //调用有参数构造函数
Method method = clazz.getMethod("show");
method.invoke(bean);
System.out.println(bean);
}
public class User {
private String name;
private int age;
public String adress = "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 void show() {
System.out.println("show");
}
private void display(String msg) {
System.out.println(msg);
}
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 +
", adress='" + adress + '\'' +
", school='" + school + '\'' +
'}';
}
}
3 反射动态获取类的结构
构造函数
成员变量
方法
注解
3.1 构造函数
- getConstructors:获取所有构造
- getConstructor(Class… args):获取指定的一个构造函数
- getDeclaredConstructor:获得构造函数,包括private的构造函数
- newInstance(Object… args):执行构造函数产生对象
/**
* 获取构造函数
*/
@Test
public void test1() throws Exception {
Class clazz = Class.forName("vo.User");
// Constructor[] constructors = clazz.getConstructors(); //获取所有构造函数(public)
Constructor[] constructors = clazz.getDeclaredConstructors(); //获取所有构造函数(private)
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("jackson", 18);
System.out.println(user);
Constructor<User> con3 = clazz.getDeclaredConstructor(String.class); //不能得到私有的构造函数
con3.setAccessible(true);
//能够使用私有的构造函数产生对象?
User u3 = con3.newInstance("john");
System.out.println(u3);
}
3.2 类结构调用的安全检查
setAccessible:默认是false,表示进行安全检查,存在安全检查时,不能访问private,设置为true,表示可以访问。
Constructor<User> con3 = clazz.getDeclaredConstructor(String.class); //不能得到私有的构造函数
con3.setAccessible(true);
//能够使用私有的构造函数产生对象?
User u3 = con3.newInstance("john");
System.out.println(u3);
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("vo.User");
Object bean = clazz.newInstance(); //调用无参构造函数产生对象
// Field[] fields = clazz.getFields();//得到所有权限范围内的变量
Field[] fields = clazz.getDeclaredFields();//得到所有权限范围内的变量
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, "mickey");
System.out.println(field.get(bean));
System.out.println(bean);
}
3.4 面试题
如何在不改变String内存地址的情况下,改变String的内容
@Test
public void test3() {
String s = new String("abc"); //堆里面产生s
String s1 = s; //s1
s = "123";
String s2 = s;
System.out.println(s1.hashCode() + " " + s2.hashCode() );
System.out.println(s1 == s2);
}
@Test
public void test4() throws Exception {
String s = new String("123"); //堆里面产生s
String s1 = s; //s1
Field vf = String.class.getDeclaredField("value");
vf.setAccessible(true);
char[] chars = {97, 98, 99};
vf.set(s, chars);
String s2 = s;
System.out.println(s1.hashCode() + " " + s2.hashCode() );
System.out.println(s1 == s2);
}
3.5 成员方法
- getMethods:得到类的所有方法,包括父类的方法
- getDeclaredMethods:得到当前类的所有方法,包括private
- getMethod(方法名,方法参数列表…):得到指定的方法
- getDeclaredMethod:得到指定的私有方法
- method.invoke(对象实例,方法的参数值列表):调用方法
@Test
public void test5() throws Exception {
Class clazz = Class.forName("vo.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");
}