Java基础（九）反射（reflection）
1.反射库（reflection library）提供了一个非常丰富且精心设计的工具集，以便编写能够动态操纵Java代码的程序。
能够分析类能力的程序称为反射（reflection）。反射机制的功能极其强大，例如：
- 在运行时分析类的能力
- 在运行时查看对象
- 实现通用的数组操作代码
- 利用Method对象
2.Class类
在程序运行期间，Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行。然而，可以通过Java类访问这些信息，保存这些信息的类被称为Class。
获得Class类的实例一共有三种方法：
（1）Object类中的getClass方法将会返回一个Class类型的实例，一个Class类型的实例表示一个特定类的属性，最常用的Class方法时getName方法，这个方法将返回类的名字。
Class class1 = alice1.getClass(); System.out.println(class1.getName()); // 打印：包名.Emplayee Class class2 = carl.getClass(); System.out.println(class2.getName()); // 打印：包名.Manager
（2）可以通过静态方法forName获得类名对应的Class对象：如果类名保存在字符串中，并想要在运行中改变，就可以使用这个方法。这个方法只能在className是类名或接口名时才能够执行。否则，将抛出一个checked exception异常。因此，使用这个方法的时候需要提供一个异常处理器。
String className = "java.util.Random"; Class class3 = Class.forName(className); System.out.println(class3.getName()); // 打印：java.util.Random
实际应用时应该提供一个异常处理器：
try { // print class name and superclass name (if != Object) Class cl = Class.forName(name); do something with cl; } catch (Exception e) { e.printStackTrace(); }
（3）如果T是任意的Java类型，则T.class将代表匹配的类对象。一个Class类对象实际上表示的是一个类型，而这个类型未必一定是一种类。int不是类，但int.class是一个Class类型的对象。
Class cl1 = int.class; System.out.println(cl1.getName()); // 打印：int Class cl2 = Double.class; System.out.println(cl2.getName()); // 打印：java.lang.Double
其他Class方法：
（1）比较两个类对象：
Employee e； if(e.getClass() == Employee.class) ...;
（2）动态地创建一个类的实例：newInstance方法调用类的默认的构造器，即没有参数的构造器初始化新创建的类对象。如果没有默认构造器，就抛出一个异常。
e.getClass().newInstance();
（3）将forName与newInstance配合使用，就可以创建执行类名的类的一个实例
String className = "java.util.Random";
Object m = Class.forName(s).newInstance();
3.利用反射分析类的能力
反射机制最重要的就是检查类的结构。
（1）打印含修饰符的类名和父类类名
// print class name and superclass name (if != Object)
Class cl = Class.forName(name);
System.out.println(cl.getName()); // 打印：java.lang.Double
Class supercl = cl.getSuperclass();
System.out.println(supercl.getName()); // 打印：java.lang.Number
// getModifiers()方法将返回一个整型数值，用不同的位开关描述public和static这样的修饰符使用情况。
// Modifier类还有isPublic、isPrivate等等用来判断方法或构造器是否是Public、Private等等
System.out.println(cl.getModifiers()); // 打印：17
String modifiers = Modifier.toString(cl.getModifiers()); // 打印：public final
System.out.println(modifiers);
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());
输入：String name = “java.lang.Double”
输出：public final class java.lang.Double extends java.lang.Number
（2）打印类中所有的构造器名
/** * Prints all constructors of a class * @param cl a class */ public static void printConstructors(Class cl) { Constructor[] constructors = cl.getDeclaredConstructors(); // 返回全部构造器，不包括由超类继承的 // getConstructors()将返回类提供的构造器数组，包括超类的构造器 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 + "("); // print parameter types 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 java.lang.Double(double);
public java.lang.Double(java.lang.String)
（3）打印类中所有的方法名
/** * Prints all methods of a class * @param cl a class */ 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(" "); // print modifiers, return type and method name String modifiers = Modifier.toString(m.getModifiers()); if (modifiers.length() > 0) System.out.print(modifiers + " "); System.out.print(retType.getName() + " " + name + "("); // print parameter types 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 boolean equals(java.lang.Object);
public static java.lang.String toString(double);
public java.lang.String toString();
...
（3）打印类中所有的域名
/** * Prints all fields of a class * @param cl a class */ 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 + ";"); } }
输出：
public static final double POSITIVE_INFINITY;
public static final double NEGATIVE_INFINITY;
public static final double NaN；
...
private final double value;
private static final long serialVersionUID
4.在运行时使用反射分析对象
在前面的代码中，已经得到了全部域的域名和类型，如何查看数据域的实际内容是分析对象的重要内容。
一个例子如下，还是以Employee类为例，Employee类有三个域，它们都是私有域
public class Employee { private String name; private double salary; private LocalDate hireDay; ... }
使用getDeclaredField("name");带参数的方法可以得到Field类型的域name域对象f，然后通过f.get（obj）方法，其中obj是某个包含f域的类的对象，就可以返回一个对象，这个对象就是obj的f域。但是，这个时候会抛出一个IllegalAccessException异常，是因为name域是私有域。这时，除非有访问权限，否则Java安全机制不允许读取私有域的值。
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); Class class1 = alice1.getClass(); Field f = class1.getDeclaredField("name"); Object vObject = f.get(alice1);
输出：Exception in thread "main" java.lang.IllegalAccessException: Class bbbTest.EqualsTest can not access a member of class bbbTest.Employee with modifiers "private"...
反射机制的默认行为受限于Java的访问控制。然而，如果一个Java程序没有收到安全管理器的控制，就可以覆盖访问控制。这是，可以调用Field、Method或Constructor对象的setAccessible方法可设置为可以访问。
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); Class class1 = alice1.getClass(); Field f = class1.getDeclaredField("name"); f.setAccessible(true); Object vObject = f.get(alice1); System.out.println(vObject); // 打印：Alice Adams
加入要查看double类型的salary域，这时因为double是数值类型，而不是对象类型，所以要想解决这个问题，可以使用Field类中的getDouble方法，也可以调用get方法，这时，反射机制将会自动地将这个域值打包到相应的对象包装器找那个，这里将打包成Double。
在get到域值后，可以使用set将obj对象的f域设置成新值。
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); Class class1 = alice1.getClass(); Field f = class1.getDeclaredField("name"); f.setAccessible(true); Object vObject = f.get(alice1); System.out.println(vObject); f.set(alice1, "Lian Jiang"); Object vObject1 = f.get(alice1); System.out.println(vObject1); // 打印：Lian Jiang
5.使用反射编写泛型数组
java.lang.reflect包中的Array类允许动态地创建数组。其中，可以使用Array类中的newInstance方法，这个方法可以构造新数组，在调用它时必须提供两个参数，一个是数组的元素类型，另一个是数组的长度。
Object newArray = Array.newInstance(componentType, newLength);
因此，现在有两步要做：1.获得数组的长度。2.获得数组的元素类型
（1）获得数组的长度可以通过Array.getLength(a)或者Array类的静态getLength方法返回任意数组a的长度。
（2）在前面已经知道，可以通过Class类的getComponentType方法确定数组对应的类型。
public static Object goodCopyOf(Object a, int newLength) { Class cl = a.getClass(); // 首先取得数组a的类对象 if (!cl.isArray()) return null; // 然后确认数组a是一个数组 Class componentType = cl.getComponentType(); // 接着确定数组对应的类型 int length = Array.getLength(a); Object newArray = Array.newInstance(componentType, newLength); // 创建数组 System.arraycopy(a, 0, newArray, 0, Math.min(length, newLength)); // 将原数组中的元素拷贝到新数组中 return newArray; }
例如：
int[] a = { 1, 2, 3 }; a = (int[]) goodCopyOf(a, 10); System.out.println(Arrays.toString(a)); // 打印：[1, 2, 3, 0, 0, 0, 0, 0, 0, 0] String[] b = { "Tom", "Dick", "Harry" }; b = (String[]) goodCopyOf(b, 10); // 打印：[Tom, Dick, Harry, null, null, null, null, null, null, null] System.out.println(Arrays.toString(b));
6.使用反射调用任意方法
（1）首先，使用Method类getMethod获得Method对象
Method square = MethodTableTest.class.getMethod("square", double.class); System.out.println(square); // 打印：public static double aaaaTest.MethodTableTest.square(double) Method sqrt = Math.class.getMethod("sqrt", double.class); System.out.println(sqrt); // 打印：public static double java.lang.Math.sqrt(double)
（2）然后通过invoke方法调用：f是square或sqrt对象，第一个参数null是因为是静态方法，第二个参数是调用的方法的参数。另外，invoke方法的参数和返回值必须是Object类型的，因此必须进行多次的类型转换。
double x = 10.000;
double y = (Double) sqrt.invoke(null, x);
System.out.printf("%10.4f%n", y); // 打印：3.1623
