void port 令行 sage [0 ray 输出 我们
在 Java 运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法?
答案是肯定的。
这种动态获取类的信息以及动态调用对象的方法的功能来自于 Java 语言的反射(Reflection)机制。
Java 反射机制主要提供了以下功能:
1. 在运行时判断任意一个对象所属的类。
2. 在运行时构造任意一个类的对象。
3. 在运行时判断任意一个类所具有的成员变量和方法。
4. 在运行时调用任意一个对象的方法。
Reflection 是 Java 被视为动态(或准动态)语言的一个关键性质。
这个机制允许程序在运行时透过 Reflection APIs 取得任何一个已知名称的 class 的内部信息。
包括其 modifiers(诸如 public、static 等)、 superclass(例如 Object)、实现了的 interfaces (例如 Serializable)、也包括其 fields 和 methods 的所有信息,并可于运行时改变 fields 内容或调用 methods。
动态语言的定义 "程序运行时,允许改变程序结构或者变量类型,这种语言称为动态语言"。
从这个观点看,Perl,Python,Ruby 是动态语言,C++,Java,C# 不是动态语言。
尽管在这样的定义与分类下 Java 不是动态语言,它却有着一个非常突出的动态相关机制:Reflection。这个字的意思是:反射、映像、倒影,用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes。
换句话说,Java 程序可以加载一个运行时才得知名称的 class,获悉其完整构造(但不包括 methods 定义),并生成其对象实体、或对其 fields 设值、或唤起其 methods。
这种 "看透"class 的能力(the ability of the program to examine itself)被称为 introspection(内省、内观、反省)。Reflection 和 introspection 是常被并提的两个术语。
在 JDK 中,主要由以下类来实现 Java 反射机制,这些类(除了第一个)都位于 java.lang.reflect 包中
Class 类:代表一个类,位于 java.lang 包下。
Field 类:代表类的成员变量(成员变量也称为类的属性)。
Method 类:代表类的方法。
Constructor 类:代表类的构造方法。
Array 类:提供了动态创建数组,以及访问数组的元素的静态方法。
要想使用反射,首先需要获得待操作的类所对应的 Class 对象。
Java 中,无论生成某个类的多少个对象,这些对象都会对应于同一个 Class 对象。
这个 Class 对象是由 JVM 生成的,通过它能够获悉整个类的结构。
常用的获取 Class 对象的 3 种方式:
1. 使用 Class 类的静态方法。例如:
- Class.forName("java.lang.String");
2. 使用类的. class 语法。如:
- String.class;
3. 使用对象的 getClass() 方法。如:
- String str = "aa";
- Class<?> classType1 = str.getClass();
getClass() 方法定义在 Object 类中,不是静态方法,需要通过对象来调用,并且它声明为 final,表明不能被子类所覆写。
直接 print 所获得的 Class 对象 classType 会输出:
class 完整类名
如果调用该 Class 对象的 getName() 方法,则输出完整类名,不加 class。
例程 DumpMethods 类演示了 Reflection API 的基本作用,它读取命令行参数指定的类名,然后打印这个类所具有的方法信息。
- import java.lang.reflect.Method;
- public class DumpMethods
- {
- public static void main(String[] args) throws Exception //在方法后加上这句,异常就消失了
- {
- //获得字符串所标识的类的class对象
- Class<?> classType = Class.forName("java.lang.String");//在此处传入字符串指定类名,所以参数获取可以是一个运行期的行为,可以用args[0]
- //返回class对象所对应的类或接口中,所声明的所有方法的数组(包括私有方法)
- Method[] methods = classType.getDeclaredMethods();
- //遍历输出所有方法声明
- for(Method method : methods)
- {
- System.out.println(method);
- }
- }
- }
通过反射调用方法。详情见代码及注释:
- import java.lang.reflect.Method;
- public class InvokeTester {
- public int add(int param1, int param2) {
- return param1 + param2;
- }
- public String echo(String message) {
- return "Hello: " + message;
- }
- public static void main(String[] args) throws Exception {
- // 以前的常规执行手段
- InvokeTester tester = new InvokeTester();
- System.out.println(tester.add(1, 2));
- System.out.println(tester.echo("Tom"));
- System.out.println("---------------------------");
- // 通过反射的方式
- // 第一步,获取Class对象
- // 前面用的方法是:Class.forName()方法获取
- // 这里用第二种方法,类名.class
- Class classType = InvokeTester.class;
- // 生成新的对象:用newInstance()方法
- Object invokeTester = classType.newInstance();
- System.out.println(invokeTester instanceof InvokeTester); // 输出true
- // 通过反射调用方法
- // 首先需要获得与该方法对应的Method对象
- Method addMethod = classType.getMethod("add", new Class[] {
- int.class,
- int.class
- });
- // 第一个参数是方法名,第二个参数是这个方法所需要的参数的Class对象的数组
- // 调用目标方法
- Object result = addMethod.invoke(invokeTester, new Object[] {
- 1,
- 2
- });
- System.out.println(result); // 此时result是Integer类型
- //调用第二个方法
- Method echoMethod = classType.getDeclaredMethod("echo", new Class[] {
- String.class
- });
- Object result2 = echoMethod.invoke(invokeTester, new Object[] {
- "Tom"
- });
- System.out.println(result2);
- }
- }
若想通过类的不带参数的构造方法来生成对象,我们有两种方式:
1. 先获得 Class 对象,然后通过该 Class 对象的 newInstance() 方法直接生成即可:
- Class<?> classType = String.class;
- Object obj = classType.newInstance();
2. 先获得 Class 对象,然后通过该对象获得对应的 Constructor 对象,再通过该 Constructor 对象的 newInstance() 方法生成
(其中 Customer 是一个自定义的类,有一个无参数的构造方法,也有带参数的构造方法):
- Class<?> classType = Customer.class;
- // 获得Constructor对象,此处获取第一个无参数的构造方法的
- Constructor cons = classType.getConstructor(new Class[] {});
- // 通过构造方法来生成一个对象
- Object obj = cons.newInstance(new Object[] {});
若想通过类的带参数的构造方法生成对象,只能使用下面这一种方式:
(Customer 为一个自定义的类,有无参数的构造方法,也有一个带参数的构造方法,传入字符串和整型)
- Class < ?>classType = Customer.class;
- Constructor cons2 = classType.getConstructor(new Class[] {
- String.class,
- int.class
- });
- Object obj2 = cons2.newInstance(new Object[] {
- "ZhangSan",
- 20
- });
可以看出调用构造方法生成对象的方法和调用一般方法的类似,不同的是从 Class 对象获取 Constructor 对象时不需要指定名字,而获取 Method 对象时需要指定名字。
来源: http://www.bubuko.com/infodetail-2111966.html