简介
Java编译分为静态编译和动态编译,动态编译灵活性高,但是速度慢,反射属于动态编译,即只有到运行时才动态创建 &获取对象实例。
编译方式说明:
1. 静态编译:在编译时确定类型 & 绑定对象。如常见的使用new
关键字创建对象
2. 动态编译:运行时确定类型 & 绑定对象。动态编译体现了Java
的灵活性、多态特性 & 降低类之间的藕合性
具体使用
实现方式
反射机制的实现 主要通过操作java.lang.Class
类:
java.lang.Class
类存放着对应类型对象的 运行时信息。
- 在
Java
程序运行时,Java
虚拟机为所有类型维护一个java.lang.Class
对象- 该
Class
对象存放着所有关于该对象的 运行时信息- 泛型形式为
Class<T>
每种类型的Class
对象只有1个 = 地址只有1个
// 对于2个String类型对象,它们的Class对象相同
Class c1 = "Will".getClass();
Class c2 = Class.forName("java.lang.String");
// 用==运算符实现两个类对象地址的比较
System.out.println(c1 ==c2);
// 输出结果:true
Java
反射机制的实现除了依靠Java.lang.Class
类,还需要依靠:Constructor
类、Field
类、Method
类,分别作用于类的各个组成部分
实现方式
在使用Java
反射机制时,主要步骤包括:
1. 获取 目标类型的Class
对象
2. 通过 Class
对象分别获取Constructor
类对象、Method
类对象 & Field
类对象
3. 通过 Constructor
类对象、Method
类对象 & Field类对象分别获取类的构造函数、方法&属性的具体信息,并进行后续操作
步骤1:获取 目标类型的Class对象
// 获取 目标类型的`Class`对象的方式主要有4种
<-- 方式1:Object.getClass() -->
// Object类中的getClass()返回一个Class类型的实例
Boolean carson = true;
Class<?> classType = carson.getClass();
System.out.println(classType);
// 输出结果:class java.lang.Boolean
<-- 方式2:T.class 语法 -->
// T = 任意Java类型
Class<?> classType = Boolean.class;
System.out.println(classType);
// 输出结果:class java.lang.Boolean
// 注:Class对象表示的是一个类型,而这个类型未必一定是类
// 如,int不是类,但int.class是一个Class类型的对象
<-- 方式3:static method Class.forName -->
Class<?> classType = Class.forName("java.lang.Boolean");
// 使用时应提供异常处理器
System.out.println(classType);
// 输出结果:class java.lang.Boolean
<-- 方式4:TYPE语法 -->
Class<?> classType = Boolean.TYPE;
System.out.println(classType);
// 输出结果:boolean
步骤2:通过 Class
对象分别获取Constructor
类对象、Method
类对象 & Field
类对象
// 即以下方法都属于`Class` 类的方法。
<-- 1. 获取类的构造函数(传入构造函数的参数类型)->>
// a. 获取指定的构造函数 (公共 / 继承)
Constructor<T> getConstructor(Class<?>... parameterTypes)
// b. 获取所有的构造函数(公共 / 继承)
Constructor<?>[] getConstructors();
// c. 获取指定的构造函数 ( 不包括继承)
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
// d. 获取所有的构造函数( 不包括继承)
Constructor<?>[] getDeclaredConstructors();
// 最终都是获得一个Constructor类对象
// 特别注意:
// 1. 不带 "Declared"的方法支持取出包括继承、公有(Public) & 不包括有(Private)的构造函数
// 2. 带 "Declared"的方法是支持取出包括公共(Public)、保护(Protected)、默认(包)访问和私有(Private)的构造方法,但不包括继承的构造函数
// 下面同理
<-- 2. 获取类的属性(传入属性名) -->
// a. 获取指定的属性(公共 / 继承)
Field getField(String name) ;
// b. 获取所有的属性(公共 / 继承)
Field[] getFields() ;
// c. 获取指定的所有属性 (不包括继承)
Field getDeclaredField(String name) ;
// d. 获取所有的所有属性 (不包括继承)
Field[] getDeclaredFields() ;
// 最终都是获得一个Field类对象
<-- 3. 获取类的方法(传入方法名 & 参数类型)-->
// a. 获取指定的方法(公共 / 继承)
Method getMethod(String name, Class<?>... parameterTypes) ;
// b. 获取所有的方法(公共 / 继承)
Method[] getMethods() ;
// c. 获取指定的方法 ( 不包括继承)
Method getDeclaredMethod(String name, Class<?>... parameterTypes) ;
// d. 获取所有的方法( 不包括继承)
Method[] getDeclaredMethods() ;
// 最终都是获得一个Method类对象
<-- 4. Class类的其他常用方法 -->
getSuperclass();
// 返回父类
String getName();
// 作用:返回完整的类名(含包名,如java.lang.String )
Object newInstance();
// 作用:快速地创建一个类的实例
// 具体过程:调用默认构造器(若该类无默认构造器,则抛出异常
// 注:若需要为构造器提供参数需使用java.lang.reflect.Constructor中的newInstance()
步骤3:通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法 & 属性的具体信息 & 进行操作
// 即以下方法都分别属于`Constructor`类、`Method`类 & `Field`类的方法。
<-- 1. 通过Constructor 类对象获取类构造函数信息 -->
String getName();// 获取构造器名
Class getDeclaringClass();// 获取一个用于描述类中定义的构造器的Class对象
int getModifiers();// 返回整型数值,用不同的位开关描述访问修饰符的使用状况
Class[] getExceptionTypes();// 获取描述方法抛出的异常类型的Class对象数组
Class[] getParameterTypes();// 获取一个用于描述参数类型的Class对象数组
<-- 2. 通过Field类对象获取类属性信息 -->
String getName();// 返回属性的名称
Class getDeclaringClass(); // 获取属性类型的Class类型对象
Class getType();// 获取属性类型的Class类型对象
int getModifiers(); // 返回整型数值,用不同的位开关描述访问修饰符的使用状况
Object get(Object obj) ;// 返回指定对象上 此属性的值
void set(Object obj, Object value) // 设置 指定对象上此属性的值为value
<-- 3. 通过Method 类对象获取类方法信息 -->
String getName();// 获取方法名
Class getDeclaringClass();// 获取方法的Class对象
int getModifiers();// 返回整型数值,用不同的位开关描述访问修饰符的使用状况
Class[] getExceptionTypes();// 获取用于描述方法抛出的异常类型的Class对象数组
Class[] getParameterTypes();// 获取一个用于描述参数类型的Class对象数组
<--额外:java.lang.reflect.Modifier类 -->
// 作用:获取访问修饰符
static String toString(int modifiers)
// 获取对应modifiers位设置的修饰符的字符串表示
static boolean isXXX(int modifiers)
// 检测方法名中对应的修饰符在modifiers中的值
访问权限的问题
反射机制的默认行为受限于Java
的访问控制,如无法访问private
的方法和属性。
Java
安全机制只允许查看任意对象有哪些域,而不允许读它们的值,若强制读取,将抛出异常。
解决方案
脱离Java
程序中安全管理器的控制、屏蔽Java
语言的访问检查,从而脱离访问控制
具体实现手段:使用Field
类、Method
类 & Constructor
类对象的setAccessible()
void setAccessible(boolean flag)
// 作用:为反射对象设置可访问标志
// 规则:flag = true时 ,表示已屏蔽Java语言的访问检查,使得可以访问 & 修改对象的私有属性
boolean isAccessible()
// 返回反射对象的可访问标志的值
static void setAccessible(AccessibleObject[] array, boolean flag)
// 设置对象数组可访问标志
简单实例
实例1:利用反射获取类的属性 & 赋值
<-- 测试类定义-->
public class Student {
public Student() {
System.out.println("创建了一个Student实例");
}
private String name;
}
<-- 利用反射获取属性 & 赋值 -->
// 1. 获取Student类的Class对象
Class studentClass = Student.class;
// 2. 通过Class对象创建Student类的对象
Object mStudent = studentClass.newInstance();
// 3. 通过Class对象获取Student类的name属性
Field f = studentClass.getDeclaredField("name");
// 4. 设置私有访问权限
f.setAccessible(true);
// 5. 对新创建的Student对象设置name值
f.set(mStudent, "will");
// 6. 获取新创建Student对象的的name属性 & 输出
System.out.println(f.get(mStudent));
结果:
//创建了一个Student实例
//will
实例2:利用反射调用类的构造函数
<-- 测试类定义-->
public class Student {
// 无参构造函数
public Student() {
System.out.println("调用了无参构造函数");
}
// 有参构造函数
public Student(String str) {
System.out.println("调用了有参构造函数");
}
private String name;
}
<-- 利用反射调用构造函数 -->
// 1. 获取Student类的Class对象
Class studentClass studentClass = Student.class;
// 2.1 通过Class对象获取Constructor类对象,从而调用无参构造方法
// 注:构造函数的调用实际上是在newInstance(),而不是在getConstructor()中调用
Object mObj1 = studentClass.getConstructor().newInstance();
// 2.2 通过Class对象获取Constructor类对象(传入参数类型),从而调用有参构造方法
Object mObj2 = studentClass.getConstructor(String.class).newInstance("will");
测试结果:
//调用了有参构造
//调用了无参构造
实例3:利用反射调用类对象的方法
<-- 测试类定义-->
public class Student {
public Student() {
System.out.println("创建了一个Student实例");
}
// 无参数方法
public void setName1 (){
System.out.println("调用了无参方法:setName1()");
}
// 有参数方法
public void setName2 (String str){
System.out.println("调用了有参方法setName2(String str):" + str);
}
}
<-- 利用反射调用方法 -->
// 1. 获取Student类的Class对象
Class studentClass = Student.class;
// 2. 通过Class对象创建Student类的对象
Object mStudent = studentClass.newInstance();
// 3.1 通过Class对象获取方法setName1()的Method对象:需传入方法名
// 因为该方法 = 无参,所以不需要传入参数
Method msetName1 = studentClass.getMethod("setName1");
// 通过Method对象调用setName1():需传入创建的实例
msetName1.invoke(mStudent);
// 3.2 通过Class对象获取方法setName2()的Method对象:需传入方法名 & 参数类型
Method msetName2 = studentClass.getMethod("setName2",String.class);
// 通过Method对象调用setName2():需传入创建的实例 & 参数值
msetName2.invoke(mStudent,"will");
测试结果:
创建了一个Student实例
调用了无参方法:setName1()
调用了有参方法setName2(String str):will
反射运用得最多的就是动态代理了,接下来会在设计模式中重点学习这方面的内容。