[关闭]
@gnudennis 2015-04-26T15:05:41.000000Z 字数 7664 阅读 2718

Core Java笔记 3.反射

CoreJava

本章重点：

  • Class 类
  • 利用反射分析类
  • 在运行时使用反射分析对象
  • 使用反射编写泛型数组代码
  • 方法指针
能够分析类能力的程序称为反射(reflective). Java 提供了丰富且精心设计的工具集(reflection library).

Class 类

在程序运行期间，Java 运行时系统始终为所有的对象维护着一个运行时的类型标识，这个信息保存着每个对象所属的类足迹.

获取 Class 实例.

  1. // 1. 通过实例获得.
  2. Employee e;
  3. Class cl = e.getClass();
  5. // 2. 通过类名获得.
  6. String className = "java.util.Date";
  7. Class cl = Class.forName(className); // need try...catch
  9. // 3. 通过类获得.
  10. Class cl = Date.class
  11. Class cl = int.class

虚拟机为每个类型管理一个Class对象.

  1. if (e.getClass = Employee.class) ...

通过 Class 创建实例.

  1. e.getClass().newInstance();   // 需要有无参构造器
  2. Date.getClass().newInstance();
  3. Class.forName("xxx").newInstance();

利用反射分析类

在 java.lang.reflect包中的三个核心类: Field、Method、Constructor.

使用反射分析类

  1. package corejava.reflection;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Modifier;
  7. import java.util.Scanner;
  9. /**
  10.  * Created by guolong.fan on 15/4/24.
  11.  */
  12. public class ReflectionTest {
  14.     public static void main(String[] args) {
  15.         String name;
  16.         if (args.length > 0) name = args[0];
  17.         else {
  18.             Scanner in = new Scanner(System.in);
  19.             System.out.println("Enter class name(e.g. java.util.Date):");
  20.             name = in.next();
  21.         }
  23.         try {
  24.             // print class name and superclass name(if != Object)
  25.             Class cl = Class.forName(name);
  26.             Class supercl = cl.getSuperclass();
  27.             String modifiers = Modifier.toString(cl.getModifiers());
  28.             if (modifiers.length() > 0) System.out.print(modifiers + " ");
  29.             System.out.print("class " + name);
  30.             if (supercl != null && supercl != Object.class) {
  31.                 System.out.print(" extends " + supercl.getName());
  32.             }
  34.             System.out.println(" {");
  35.             printConstructors(cl);
  36.             System.out.println();
  37.             printMethods(cl);
  38.             System.out.println();
  39.             printFields(cl);
  40.             System.out.println("}");
  42.         } catch (ClassNotFoundException e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  47.     private static void printConstructors(Class cl) {
  48.         Constructor[] constructors = cl.getDeclaredConstructors();
  49.         for (Constructor c : constructors) {
  50.             String name = c.getName();
  51.             System.out.print("\t");
  52.             String modifiers = Modifier.toString(c.getModifiers());
  53.             if (modifiers.length() > 0) System.out.print(modifiers + " ");
  54.             System.out.print(name + "(");
  55.             Class[] paramTypes = c.getParameterTypes();
  56.             for (int j = 0; j < paramTypes.length; ++j) {
  57.                 if (j > 0) System.out.print(", ");
  58.                 System.out.print(paramTypes[j].getName());
  59.             }
  60.             System.out.print(")");
  61.             Class[] expTypes = c.getExceptionTypes();
  62.             if (expTypes.length > 0) System.out.print(" throws ");
  63.             for (int j = 0; j < expTypes.length; ++j) {
  64.                 if (j > 0) System.out.print(", ");
  65.                 System.out.print(expTypes[j].getName());
  66.             }
  67.             System.out.println(";");
  68.         }
  69.     }
  71.     private static void printMethods(Class cl) {
  72.         Method[] methods = cl.getDeclaredMethods();
  73.         for (Method m : methods) {
  74.             String name = cl.getName();
  75.             Class refType = m.getReturnType();
  77.             System.out.print("\t");
  78.             String modifiers = Modifier.toString(m.getModifiers());
  79.             if (modifiers.length() > 0) System.out.print(modifiers + " ");
  80.             System.out.print(refType.getName() + " ");
  81.             System.out.print(name + "(");
  82.             Class[] paramTypes = m.getParameterTypes();
  83.             for (int j = 0; j < paramTypes.length; ++j) {
  84.                 if (j > 0) System.out.print(", ");
  85.                 System.out.print(paramTypes[j].getName());
  86.             }
  87.             System.out.print(")");
  89.             Class[] expTypes = m.getExceptionTypes();
  90.             if (expTypes.length > 0) System.out.print(" throws ");
  91.             for (int j = 0; j < expTypes.length; ++j) {
  92.                 if (j > 0) System.out.print(", ");
  93.                 System.out.print(expTypes[j].getName());
  94.             }
  95.             System.out.println(";");
  96.         }
  97.     }
  99.     private static void printFields(Class cl) {
  100.         Field[] fields = cl.getDeclaredFields();
  101.         for (Field f : fields) {
  102.             String name = f.getName();
  103.             Class type = f.getType();
  105.             String modifiers = Modifier.toString(f.getModifiers());
  106.             System.out.print("\t");
  108.             if (modifiers.length() > 0) System.out.print(modifiers + " ");
  109.             System.out.println(type.getName() + " " + name + ";");
  110.         }
  111.     }
  113. }

在运行时使用反射分析对象

实现通用的toString.

  1. package corejava.reflection;
  3. import java.lang.reflect.AccessibleObject;
  4. import java.lang.reflect.Array;
  5. import java.lang.reflect.Field;
  6. import java.lang.reflect.Modifier;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. /**
  11.  * Created by guolong.fan on 15/4/24.
  12.  */
  13. public class ObjectAnalyzer {
  15.     /**
  16.      * Converts an object to a string representation that lists all fields.
  17.      * @param obj an object
  18.      * @return a string with the obejct's class name and all fields name and
  19.      * values
  20.      */
  21.     public String toString(Object obj) {
  22.         if (obj == null) return "null";
  23.         if (visited.contains(obj)) return "...";
  24.         visited.add(obj);
  26.         Class cl = obj.getClass();
  27.         if (cl == String.class) return (String)obj;
  28.         if (cl.isArray()) {
  29.             String r = cl.getComponentType() + "[]{";
  30.             for (int i = 0; i < Array.getLength(obj); ++i) {
  31.                 if (i > 0) r += ",";
  32.                 Object val = Array.get(obj, i);
  33.                 if (cl.getComponentType().isPrimitive()) r += val;
  34.                 else r += toString(val);
  36.             }
  37.             return r + "}";
  38.         }
  40.         String r = cl.getName();
  42.         // inspect the fields of this class and all superclasses
  43.         do {
  44.             r += "[";
  45.             Field[] fields = cl.getDeclaredFields();
  46.             AccessibleObject.setAccessible(fields, true);
  48.             for (Field f : fields) {
  49.                 if (!Modifier.isStatic(f.getModifiers())) {
  50.                     if (!r.endsWith("[")) r += ",";
  51.                     r += f.getName() + "=";
  52.                     try {
  53.                         Class t = f.getType();
  54.                         Object val = f.get(obj);
  55.                         if (t.isPrimitive()) r += val;
  56.                         else r += toString(val);
  57.                     } catch (Exception e) {
  58.                         e.printStackTrace();
  59.                     }
  60.                 }
  61.             }
  62.             r += "]";
  63.             cl = cl.getSuperclass();
  64.         } while (cl != null);
  66.         return r;
  67.     }
  69.     private List<Object> visited = new ArrayList<Object>();
  71.     public static void main(String[] args) {
  72.         ArrayList<Integer> squares = new ArrayList<Integer>();
  73.         for (int i = 0; i < 5; ++i) {
  74.             squares.add(i * i);
  75.         }
  76.         System.out.println(new ObjectAnalyzer().toString(squares));
  77.         System.out.println(squares);
  78.     }
  79. }

使用反射编写泛型数组代码

  1. package corejava.reflection;
  3. import java.lang.reflect.Array;
  5. /**
  6.  * Created by guolong.fan on 15/4/24.
  7.  */
  8. public class ArrayGrowTest {
  10.     public static void main(String[] args) {
  11.         int[] a = { 1, 2, 3 };
  12.         a = (int[])goodArrayGrow(a);
  14.         String[] b = { "Tom", "Dick", "Harry" };
  15.         b = (String[]) goodArrayGrow(b);
  17.         // Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
  18.         // at corejava.reflection.ArrayGrowTest.main(ArrayGrowTest.java:10)
  19.         System.out.println("The following call will generate an exception.");
  20.         b = (String[])badArrayGrow(b);
  22.         // 要理解这些，需要把泛型数组看成一种类型。Integer[] 和 Object[] 不是一种类型!!!
  23.         // 有自己的 Class 对象!!!
  24.         Integer[] intArr = new Integer[10];
  25.         Object[] objArr = intArr;  // OK
  27.         // Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;
  28.         // at corejava.reflection.ArrayGrowTest.main(ArrayGrowTest.java:20)
  29.         Object[] objArr2 = new Object[10];
  30.         Integer[] intArr2 = (Integer[])objArr2; // Exception
  31.     }
  33.     /**
  34.      * This method attempts to grow an array by alocating a new array and copying all elements.
  35.      * @param a the array to grow
  36.      * @return a larger array that contains all elements of a. However, the returned array has
  37.      * type Object[], not the same type as a.
  38.      */
  39.     static Object[] badArrayGrow(Object[] a) {
  40.         int newLength = a.length * 11 / 10 + 10;
  41.         Object[] newArray = new Object[newLength];
  42.         System.arraycopy(a, 0, newArray, 0, a.length);
  43.         return newArray; // newArray is Object[], not the same type as a.
  44.     }
  46.     /**
  47.      * This method grows an array by allocating a new array of the same type and
  48.      * copying all elements.
  49.      * @param a the array to grow. This can be an object array or a primitive
  50.      *          type array
  51.      * @return a larger array that contains all elements of a.
  52.      */
  53.     static Object goodArrayGrow(Object a) {
  54.         if (a == null) return null;
  56.         Class cl = a.getClass();
  57.         if (!cl.isArray()) return null;
  59.         Class componentType = cl.getComponentType();
  60.         int length = Array.getLength(a);  // 获取a的类型
  61.         int newLength = length * 11 / 10 + 10;
  63.         Object newArray = Array.newInstance(componentType, newLength); // newArray is the same type as a!!
  64.         System.arraycopy(a, 0, newArray, 0, length);
  65.         return newArray;
  66.     }
  68. }

方法指针

Java 没有提供方法指针，但是利用反射可以实现方法指针，但是从设计角度来说，方法指针会来带隐患. interface 是更好的解决方案.

  1. Method m1 = Employee.class.getMethod("getName");
  2. Method m2 = Employee.class.getMethod("raiseSalary", double.class);
  4. Employee e = new Employee();
  5. m1.invoke(e);
  6. m2.invoke(e, 1.0);

示例:

  1. package corejava.reflection;
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  6. /**
  7.  * Created by guolong.fan on 15/4/24.
  8.  */
  9. public class MethodPointerTest {
  11.     public static void main(String[] args) throws NoSuchMethodException {
  12.         Method square = MethodPointerTest.class.getMethod("squre", double.class);
  13.         printTable(1, 10, 10, square);
  14.     }
  16.     public static double squre(double x) {
  17.         return x * x;
  18.     }
  20.     private static void printTable(double from, double to, int n, Method f) {
  21.         double dx = (to - from) / (n - 1);
  22.         for (double x = from; x <= to; x += dx) {
  24.             try {
  25.                 double y = (Double)f.invoke(null, x);
  26.                 System.out.printf("%10.4f | %10.4f\n", x, y);
  27.             } catch (IllegalAccessException e) {
  28.                 e.printStackTrace();
  29.             } catch (InvocationTargetException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  34. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注