5.7 反射
反射（reflection library）提供了动态操作java代码程序的方法，这项功能被大量应用于JavaBean中，使用反射，在设计或运行添加新类的时候，能够快速地应用开发工具动态查找新添加类的能力。
能够分析类能力的程序叫做反射（reflective）。
- 在运行中分析类的能力；
- 在运行中查看对象；
- 实现通用的数组操作代码；
- 利用Method对象。
5.7.1 Class类
在程序运行期间，java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类，JVM利用运行时类型信息选择相应的方法执行。
可以通过专门的Java类访问这些信息，保存这些信息的类被称为Class，Object类中的getClass()方法将会返回一个Class类型的实例。
Employee e; ... Class cl = e.getClass();
如同用一个Employee对象表示一个特定的雇员属性一样，一个Class对象将表示一个特定类的属性。最常用的Class方法是getName。这个方法返回类的名字。
System.out.println(e.getClass().getName() + " " + e.getName());
如果e是一个雇员，会打印出：
Employee Harry Hacker
如果e是一个经理，会打印出：
Manager Harry Hacker
如果类在一个包里，包的名字也作为类名的一部分：
Date d = new Date(); Class cl = d.getClass(); String name = cl.getName();
也可以调用静态方法forName获得类名对应的Class对象。
String className = "java.util.Date"; Class cl = Class.forName(className);
如果类名保存在字符串中，并可在运行中改变，就可以使用这个方法。这个方法只有在className是类名或接口名的时候才能执行。否则，forName方法将会抛出一个checkedexception异常（已检查异常）。无论何时使用这个方法，都应该提供一个异常处理器（execption handler）。
获得Class类对象的第三种方法非常简单，如果T是任意的java类型，T.class将代表匹配的类对象。例如：
Class cl1 = Date.class; Class cl2 = int.class; Class cl3 = Double[].class;
一个Class对象实际上表示的是一个类型，而这个类型未必一定是一种类，例如，int不是类，但int.class是一个Class类型的对象。
JVM为每个类管理一个Class对象，因此，可以利用==运算符实现两个类对象比较的操作。例如：
if(e.getClass() == Employe.class)
...
还有一个很有用的方法newInstance()，可以用来快速地创建一个类的实例。例如，
e.getClass().newInstance();
创建一个与e具有相同类型的实例，newInstance方法调用默认的构造器（没有参数的构造器）初始化新创建的对象。如果这个类没有默认的构造器，就会抛出一个异常。
将forName域newInstance配合起来使用，可以根据存储在字符串中的类名创建一个对象。
String s = "java.util.Date"; Object m = Class.forName(s).newInstance();
5.7.3 利用反射分析类的能力
java.lang.reflect中包含三个类Filed、Method和Constructor分别用于描述类的域、方法和构造器。
Filed类： getDeclaredFileds()
getName（返回项目的名称）、getType（返回域所属的类型）、getModifiers（返回一个整型数值，描述修饰符的情况）
Method类： getDeclaredMethods()
getName（返回项目的名称）、getModifiers（返回一个整型数值，描述修饰符的情况）、getReturnType（返回值类型）、 getParameterTypes（返回参数类型）
Constructors类： getDeclaredConstructors()
getName（返回项目的名称）、 getParameterTypes（返回参数类型）
package reflect_5_13;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
public class ReflectionTest {
public static void main(String args[])
{
String name;
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();
}
try
{
//首先用cl保存获取的name.class
Class cl = Class.forName(name);
//获得超类supercl
Class supercl = cl.getSuperclass();
//获取cl的修饰语（public/private/final...）
String modifiers = Modifier.toString(cl.getModifiers());
if(modifiers.length() > 0)
System.out.print(modifiers + " ");
System.out.print("class " + name);
if(supercl != null && supercl != Object.class)
System.out.print("extends " + supercl.getName());
System.out.print("
{
");
printConstructors(cl);
System.out.println();
printMethods(cl);
System.out.println();
printFields(cl);
System.out.println("}");
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
System.exit(0);
}
/*
* 输出所有的构造器
*/
public static void printConstructors(Class cl)
{
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 + "(");
//构造器的参数类型
Class[] paramTypes = c.getParameterTypes();
for(int j = 0; j < paramTypes.length; j++)
{
if(j > 0)
{
System.out.print(", ");
}
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
/*
* 输出所有的方法
*/
public static void printMethods(Class cl)
{
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 + "(");
//将参数类型打印出来
Class[] paramTypes = m.getParameterTypes();
for(int j = 0; j < paramTypes.length; j++)
{
if(j > 0)
{
System.out.print(", ");
}
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
/*
* 输出所有的域
*/
public static void printFields(Class cl)
{
Field[] fields = cl.getDeclaredFields();
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 + " ");
}
}
}
}
输出结果：
Enter class name(e.g.java.util.Date):
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();
private final sun.util.calendar.BaseCalendar$Date normalize(sun.util.calendar.BaseCalendar$Date);
public static long parse(java.lang.String);
public static long UTC(int, int, int, int, int, int);
public int getDate();
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(long);
private static final sun.util.calendar.BaseCalendar getCalendarSystem(int);
private static final sun.util.calendar.BaseCalendar getCalendarSystem(sun.util.calendar.BaseCalendar$Date);
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();
public void setTime(long);
public static java.util.Date from(java.time.Instant);
public long getTime();
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
}
构造器：名称、修饰符、参数类型
方法：名称、修饰符、参数类型、返回类型
域：名称、类型
其他的API还需要详细的了解。
5.7.4 在运行时使用反射分析对象
查看任意对象的数据域名称和类型：
1、获得对于的Class对象；
2、通过Class对象调用getDeclaredFields。
在编写程序的时候，如果知道想要查看的域名和类型，查看指定的域是一件很容易的事情，而利用反射机制可以查看在编译时还不清楚的对象域。
查看对象域的关键方法是Field类中get方法。如果f是一个Field类型的对象（例如，通过getDeclaredFields得到的对象），obj是某个包含f域的类的对象，f.get(obj)将返回一个对象，其值为obj域的当前值。
Eployee harry = new Employee("Harry Hacker", 35000, 10, 1, 1989);
Class cl = harry.getClass();
Field f = cl.getDeclaredField("name");
Object v = f.get(harry);
实际上这段代码有问题，由于name是一个私有域，所以get方法将会抛出一个IllegalAccessException。只有利用get方法才能得到可访问域的值，除非拥有访问权限，否则Java安全机制只允许查看任意对象有那些域，而不允许读取它们的值。
反射机制的默认行为受限于java的访问控制，然而，如果一个java程序没有收到安全管理器的控制，就可以覆盖访问控制，为了达到这个目的，需要调用Field、Method或Constructor对象的setAccessible方法。例如：
f.setAccessible(true);
setAccessible方法是AccessibleObject类中的一个方法，它是Field、Method和Constructor类的公共超类。这个特性是为调试、持久化存储和相似机制提供的。
get方法还有一个需要解决的问题，nama是一个String，因此它作为Object返回没有任何问题。但是，假设我们想要查看salary域，它属于double类型，而java中数值类型不是对象。要想解决这个问题，可以使用Fields类中的getDouble方法，也可以调用get方法，此时，反射机制将会自动将这个域值打包到对应的对象包装器中，这里将打包成Double。
调用f.get(obj, value)可以将obj对象的f域设置为新值。
使用getDeclaredFields获得所有的数据域，然后使用setAccessible将所有的域设置为可访问的，对于每个域，获得了名字和值。
