能够分析类能力的程序称为反射
反射可以用来
- 在运行的时候分析类的能力
- 在运行的时候检查对象
- 实现泛型数组操作代码
- 利用Method对象
①Class类
Java运行时虚拟机始终为所有对象维护一个运行时类型标记，这个信息会跟踪每个对象所属的类
用一个叫做Class的特殊的类保存这些信息
- Object类中的getClass()方法会返回一个Class类型的实例
Employee e;
Class cl = e.getClass();
Class对象描述一个特定类的属性，上面代码中的对象cl描述的就是Employee类的属性
-
Class类常用方法getName()
返回class对象对应的类的名称
System.out.println(e.getClass().getName()+" "+e.getName());
//e是员工，输出"Employee Harry Hacker"
//e是经理，输出"Manager Harry Hacker"
-
forName()方法
作用：加载指定类名的class对象
Class cl = Class.forName("Employee");
上例代码中，forName方法通过参数"Employee"指定了class对象cl描述的类是Employee类
注意：常与异常处理器配合使用
- T.class快捷方式获得class对象
Class cl = int.class;
这里自动给cl匹配了class对象（根据int类型分配了Integer类）
虚拟机为每个类型管理一个唯一的class对象，因此可以使用==实现两个类对象的比较
if(e.getClass()==Employee.getClass()){
...
}
-
获取类的构造方法
使用getConstructor()方法获取当前class对象所指的类的构造方法
再使用newInstance()创建一个所指的类的对象
Class cl = Employee.class;
Employee e = cl.getConstructor().newInstance();
上面代码用Employee类的无参构造方法构造了一个新的Employee对象
②异常处理
无法确定通过Class.forName方法指定的类一定存在
需要在方法名上增加一个throws子句来处理这个异常
public static void doSomethingWithClass(String name)
throws ReflectiveOperationException
{
Class cl = Class.forName(name);//可能name指定的类是不存在的
...
}
调用这个方法的任何方法也需要一个throws声明，包括main方法
③使用反射分析类的能力
通过java.lang.reflect包中的三个类Field,Method和Constructor来描述一个类的结构，配合Modifier类描述类、方法、字段的访问权限。通常在构造一个class对象之后通过getter方法来构造这三个类(返回值通常存放在数组里)
Class cl = Class.forName(name);
Field[] fields = cl.getDeclaredFields();
Method[] methods = cl.getDeclaredMethods();
Constructor[] constructors = cl.getDeclaredConstructors();
for(Field f:fields){
String modifiers = Modifier.toString(f.getModifiers());//获取权限
}
...
下面代码的作用是输入一个类名，输出它的构造器、方法、字段
/**
* @author whl
* @date 2020/7/7 - 15:04
*/
import java.util.*;
import java.lang.reflect.*;
public class ReflectionTest {
public static void main(String[] args) throws ReflectiveOperationException{
String name;
/**
*可以在命令行运行这个类的时候加参数
* 加了就存放在args数组里
*/
if (args.length>0)
name=args[0];
else {
Scanner in = new Scanner(System.in);
System.out.println("Enter class name(e.g. java.util.Date):");
name=in.next();
}
Class cl = Class.forName(name);
Class supercl = cl.getSuperclass();//cl的父类
String modifiers = Modifier.toString(cl.getModifiers());//cl的权限修饰符
if (modifiers.length()>0)
System.out.print(modifiers+" ");
System.out.print("class "+name);
if (supercl!=null && supercl!=Object.class)//父类不能是null，同时父类不能是object
System.out.print(" extends "+supercl.getName());//显示cl继承于什么类
System.out.print("\n{\n");
printConstructors(cl);//输出构造器
System.out.println();
printMethods(cl);//输出方法
System.out.println();
printFields(cl);//输出成员
System.out.println("}");
}
private static void printFields(Class cl) {
/*
* Field类用于描述一个类的成员
* getDeclaredFields()方法返回这个类中定义的字段的数组
* getFields()方法返回这个类及其父类定义的字段的数组
* */
Field[] fields = cl.getDeclaredFields();//构造一个存放Field对象的数组
for (Field f : fields) {
Class type = f.getType();//字段的类型
String name = f.getName();//字段的名称
System.out.print(" ");//行首缩进
String modifiers = Modifier.toString(f.getModifiers());//字段的权限修饰符
if (modifiers.length()>0)
System.out.print(modifiers+" ");
System.out.println(type.getName()+" "+name+";");
}
}
private static void printMethods(Class cl) {
/*
* Method类用于描述一个类的方法
* getDeclaredMethods()方法返回这个类中定义的方法的数组
* getMethods()方法返回这个类及其父类定义的全部公共方法的数组
* */
Method[] methods = cl.getDeclaredMethods();
for (Method m : methods) {
Class retType = m.getReturnType();//方法的返回类型
String name = m.getName();//方法名称
System.out.print(" ");
String modifiers = Modifier.toString(m.getModifiers());//方法的权限修饰符
if (modifiers.length()>0)
System.out.print(modifiers + " ");
System.out.print(retType.getName()+" "+name+"(");
/*
用for循环输出方法的参数
*/
Class[] paraType = m.getParameterTypes();
for (int i = 0; i < paraType.length; i++) {
if (i>0)
System.out.print(", ");
System.out.print(paraType[i].getName());
}
System.out.println(");");
}
}
private static void printConstructors(Class cl) {
/*
* Constructor类用于描述一个类的构造器
* getDeclaredConstructors()方法返回这个类中全部构造器的数组
* getConstructors()方法返回这个类所有公共构造器的数组
* */
Constructor[] constructors = cl.getDeclaredConstructors();
for (Constructor c:constructors){
String name = c.getName();//构造器的名称
System.out.print(" ");
String modifiers = Modifier.toString(c.getModifiers());//构造器的权限修饰符
if (modifiers.length()>0)
System.out.print(modifiers+" ");
System.out.print(name+"(");
//用for循环输出构造器的参数
Class[] paraTypes = c.getParameterTypes();
for (int i = 0; i < paraTypes.length; i++) {
if (i>0)
System.out.print(", ");
System.out.print(paraTypes[i].getName());
}
System.out.println(");");
}
}
}
例：输入java.util.Date，输出结果如下
public class java.util.Date
{
public java.util.Date(int, int, int, int, int, int);
public java.util.Date(java.lang.String);
public java.util.Date();
public java.util.Date(long);
public java.util.Date(int, int, int);
public java.util.Date(int, int, int, int, int);
public boolean after(java.util.Date);
public boolean before(java.util.Date);
public boolean equals(java.lang.Object);
public java.lang.String toString();
public int hashCode();
public java.lang.Object clone();
public int compareTo(java.util.Date);
public volatile int compareTo(java.lang.Object);
private void readObject(java.io.ObjectInputStream);
private void writeObject(java.io.ObjectOutputStream);
private final sun.util.calendar.BaseCalendar$Date normalize(sun.util.calendar.BaseCalendar$Date);
private final sun.util.calendar.BaseCalendar$Date normalize();
public static long parse(java.lang.String);
public static java.util.Date from(java.time.Instant);
public long getTime();
public void setTime(long);
public int getDate();
public static long UTC(int, int, int, int, int, int);
private static final java.lang.StringBuilder convertToAbbr(java.lang.StringBuilder, java.lang.String);
private final sun.util.calendar.BaseCalendar$Date getCalendarDate();
private static final sun.util.calendar.BaseCalendar getCalendarSystem(int);
private static final sun.util.calendar.BaseCalendar getCalendarSystem(sun.util.calendar.BaseCalendar$Date);
private static final sun.util.calendar.BaseCalendar getCalendarSystem(long);
public int getDay();
public int getHours();
private static final synchronized sun.util.calendar.BaseCalendar getJulianCalendar();
static final long getMillisOf(java.util.Date);
public int getMinutes();
public int getMonth();
public int getSeconds();
private final long getTimeImpl();
public int getTimezoneOffset();
public int getYear();
public void setDate(int);
public void setHours(int);
public void setMinutes(int);
public void setMonth(int);
public void setSeconds(int);
public void setYear(int);
public java.lang.String toGMTString();
public java.time.Instant toInstant();
public java.lang.String toLocaleString();
private static final sun.util.calendar.BaseCalendar gcal;
private static sun.util.calendar.BaseCalendar jcal;
private transient long fastTime;
private transient sun.util.calendar.BaseCalendar$Date cdate;
private static int defaultCenturyStart;
private static final long serialVersionUID;
private static final [Ljava.lang.String; wtb;
private static final [I ttb;
}
④使用反射在运行时分析对象
利用反射可以查看在编译时还不知道的对象字段
- 利用Field类中的get方法来查看对象字段的值
- 利用Field类中的set方法设置对象字段的值
- 利用Field,Method,Constructor对象中的setAccessible方法覆盖Java的访问控制
Employee harry = new Employee("Harry Hacker",50000,10,1,1989);
Class cl = harry.getClass();
Field f = cl.getDeclaredField("name");//此时只是有一个field对象描述name字段
f.setAccessible();//由于name是私有字段，所以要使它可访问可修改
Object v = f.get(harry);//v是String对象，内容为"Harry Hacker"
⑤调用任意方法和构造器
- 使用Method类中的invoke方法，调用包装在当前Method对象中的方法
Employee harry = new Employee(...);
Class cl = harry.getClass();
Method ml = cl.getMethod("getName");
String n = (String)ml.invoke(harry);//在employee对象harry中调用了method对象ml描述的方法
-
也可以在调用invoke时指定参数类型
getMethod("raiseSalary",double.class);//raiseSalary的参数是double型invoke方法的签名
Object invoke(Object obj,Object... args)
