Java Reflect

综述

方法的反射

成员变量的反射

构造函数的反射

类加载机制

在面向对象的世界里，万事万物皆对象。

但在Java里面有两样东西不是对象：静态的成员、普通数据类型类(但它们有封装类弥补)

类是对象，类是 java.lang.Class 的实例对象(There is a class named Class)

package com.gcusky.reflect; class ClassDemo{ Foo foo = new Foo(); // Foo的实例对象 /** * foo 是 Foo 类的实例对象 * Foo 是 Class 类的实例对象，又叫类类型(class type) */ // 表示1 -> 任何一个类都有一个隐含的静态成员变量class Class c1 = Foo.class; // 表示2 -> 已知该类对象可用getClass方法获取类类型 Class c2 = foo.getClass(); // 表示3 -> 用类的全称获取 try { Class c3 = Class.forName("com.gcusky.reflect.Foo"); } catch (ClassNotFoundException e) { e.printStackTrace(); } // 可以通过类的类类型创建该类的实例对象 try { Foo foo1 = (Foo)c1.newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } class Foo

Java 动态加载类

Class.forName("类的全称")

不仅表示了类的类类型，还代表了动态加载类

编译时刻加载类是静态加载类

运行时刻加载类是动态加载类

class Office{ public static void main(String[] args){ // new 创建对象，是静态加载类，在编译时就需要加载所有可能使用到的类 if("Word".equals(args[0])) { Word w = new Word(); w.start(); } // Class.forName 创建对象，是动态加载类，在运行时才加载 try { Class c = Class.forName(args[0]) Word w = (Word) c.newInstance(); // 通过类类型，创建该对象 w.start(); } catch (Exception e) { e.printStackTrace(); } } }

Java 获取方法信息

基本的数据类型，

java.lang.reflect.Method 封装了关于方法的操作

button" class="copyCode code-tool" data-toggle="tooltip" data-placement="top" data-clipboard-text="package com.gcusky.reflect; import java.lang.reflect.Method; public class Demo { /** * 打印类的信息，包括类的成员函数、成员变量 * @param obj 对象 */ public static void printClassMessage(Object obj) { // 要获取类的信息，首先要获取类的类类型 Class c = obj.getClass(); // 获取类的全名 String fullName = c.getName(); /** * Method类：方法对象 * 一个成员方法就是一个Method对象 * getMethods()方法获取的是所有的public的函数，包括父类继承而来的 * getDeclaredMethods() 获取的是所有该类自己声明的方法，不问访问权限 */ Method[] ms = c.getMethods(); // c.getDeclaredMethods(); for (int i = 0; i < ms.length; i++) { // 得到方法的返回类型 Class returnType = ms[i].getReturnType(); // 得到方法的名称 String name = ms[i].getName(); // 获取参数类型 Class[] paramTypes = ms[i].getParameterTypes(); } } }" title="" data-original-title="复制">

package com.gcusky.reflect; import java.lang.reflect.Method; public class Demo{ /** * 打印类的信息，包括类的成员函数、成员变量 * @param obj 对象 */ public static void printClassMessage(Object obj){ // 要获取类的信息，首先要获取类的类类型 Class c = obj.getClass(); // 获取类的全名 String fullName = c.getName(); /** * Method类：方法对象 * 一个成员方法就是一个Method对象 * getMethods()方法获取的是所有的public的函数，包括父类继承而来的 * getDeclaredMethods() 获取的是所有该类自己声明的方法，不问访问权限 */ Method[] ms = c.getMethods(); // c.getDeclaredMethods(); for (int i = 0; i < ms.length; i++) { // 得到方法的返回类型 Class returnType = ms[i].getReturnType(); // 得到方法的名称 String name = ms[i].getName(); // 获取参数类型 Class[] paramTypes = ms[i].getParameterTypes(); } } }

Java 获取成员变量信息

成员变量也是对象

java.lang.reflect.Field 封装了关于成员变量的操作

button" class="copyCode code-tool" data-toggle="tooltip" data-placement="top" data-clipboard-text=" /** * 成员变量也是对象，Field封装了关于成员变量的操作 * getFields()获取的是所有的public的成员变量 * getDeclaredMethods()获取的是所有该类自己声明的成员变量 */ Field[] fs = c.getDeclaredFields(); // c.getFields(); for (int i = 0; i < fs.length; i++) { // 得到成员变量的类型 Class fieldType = fs[i].getType(); String typeName = fieldType.getName(); // 得到成员变量的名称 String fieldName = fs[i].getName(); }" title="" data-original-title="复制">

/** * 成员变量也是对象，Field封装了关于成员变量的操作 * getFields()获取的是所有的public的成员变量 * getDeclaredMethods()获取的是所有该类自己声明的成员变量 */ Field[] fs = c.getDeclaredFields(); // c.getFields(); for (int i = 0; i < fs.length; i++) { // 得到成员变量的类型 Class fieldType = fs[i].getType(); String typeName = fieldType.getName(); // 得到成员变量的名称 String fieldName = fs[i].getName(); }

Java 获取构造函数信息

/** * 构造函数也是对象 * java.lang.Constructor中封装了构造函数的信息 */ Constructor[] cs = c.getDeclaredConstructors(); for (Constructor constructor : cs) { constructor.getName(); Class[] paramType = constructor.getParameterTypes(); }

Java 方法的反射

如何获取某个方法：方法的名称和方法的参数列表才能唯一决定某个方法

方法反射的操作：method.invoke(对象, 参数列表)

class A{ public void print(int a, int b){ System.out.println(a + b); } } A a = new A(); Class c = a.getClass(); try { // Method m = c.getMethod("print", new Class[]{int.class, int.class}); Method m = c.getMethod("print", int.class, int.class); // Object o = m.invoke(a, new Object[]{10, 20}); Object o = m.invoke(a, 10, 20); } catch (Exception e) { e.printStackTrace(); }

Java 类加载机制

ArrayList list = new ArrayList(); ArrayListlist1 = new ArrayList(); list == list1; // true list1.add(20); // error - 编译检测出错" title="" data-original-title="复制">

ArrayList list = new ArrayList(); ArrayList list1 = new ArrayList(); list == list1; // true list1.add(20); // error - 编译检测出错

反射都是编译之后的操作，因此可看出泛型在编译之后会被擦除

Java 中集合的泛型用于防止错误输入，只在编译阶段有效，绕过编译则无效

Class c = list1.getclass(); try { Method m = c.getMethod("add", Object.class); m.invoke(list1, 20); // correct - 绕过编译操作就绕过了泛型 } catch (Exception e) { e.printStackTrace(); }