如果不知道一个对象的准确类型，RTTI会帮助我们调查。但却有一个限制：类型必须是在编译期间已知的，否则就不能用RTTI调查它，进而无法展开下一步的工作。换言之，编译器必须明确知道RTTI要处理的所有类。

从表面看，这似乎并不是一个很大的限制，但假若得到的是一个不在自己程序空间内的对象的引用，这时又会怎样呢？事实上，对象的类即使在编译期间也不可由我们的程序使用。例如，假设我们从磁盘或者网络获得一系列字节，而且被告知那些字节代表一个类。由于编译器在编译代码时并不知道那个类的情况，所以怎样才能顺利地使用这个类呢？

在传统的程序设计环境中，出现这种情况的概率或许很小。但当我们转移到一个规模更大的编程世界中，却必须对这个问题加以高度重视。第一个要注意的是基于组件的程序设计。在这种环境下，我们用“快速应用开发”（RAD）模型来构建程序项目。RAD一般是在应用程序构建工具中内建的。这是编制程序的一种可视途径（在屏幕上以窗体的形式出现）。可将代表不同组件的图标拖曳到窗体中。随后，通过设定这些组件的属性或者值，进行正确的配置。设计期间的配置要求任何组件都是可以“例示”的（即可以自由获得它们的实例）。这些组件也要揭示出自己的一部分内容，允许程序员读取和设置各种值。此外，用于控制GUI事件的组件必须揭示出与相应的方法有关的信息，以便RAD环境帮助程序员用自己的代码覆盖这些由事件驱动的方法。“反射”提供了一种特殊的机制，可以侦测可用的方法，并产生方法名。通过Java Beans（第13章将详细介绍），Java 1.1为这种基于组件的程序设计提供了一个基础结构。

在运行期查询类信息的另一个原动力是通过网络创建与执行位于远程系统上的对象。这就叫作“远程方法调用”（RMI），它允许Java程序（版本1.1以上）使用由多台机器发布或分布的对象。这种对象的分布可能是由多方面的原因引起的：可能要做一件计算密集型的工作，想对它进行分割，让处于空闲状态的其他机器分担部分工作，从而加快处理进度。某些情况下，可能需要将用于控制特定类型任务（比如多层客户／服务器架构中的“运作规则”）的代码放置在一台特殊的机器上，使这台机器成为对那些行动进行描述的一个通用储藏所。而且可以方便地修改这个场所，使其对系统内的所有方面产生影响（这是一种特别有用的设计思路，因为机器是独立存在的，所以能轻易修改软件！）。分布式计算也能更充分地发挥某些专用硬件的作用，它们特别擅长执行一些特定的任务——例如矩阵逆转——但对常规编程来说却显得太夸张或者太昂贵了。

在Java 1.1中，Class类（本章前面已有详细论述）得到了扩展，可以支持“反射”的概念。针对Field，Method以及Constructor类（每个都实现了Memberinterface——成员接口），它们都新增了一个库：java.lang.reflect。这些类型的对象都是JVM在运行期创建的，用于代表未知类里对应的成员。这样便可用构造器创建新对象，用get()和set()方法读取和修改与Field对象关联的字段，以及用invoke()方法调用与Method对象关联的方法。此外，我们可调用方法getFields()，getMethods()，getConstructors()，分别返回用于表示字段、方法以及构造器的对象数组（在联机文档中，还可找到与Class类有关的更多的资料）。因此，匿名对象的类信息可在运行期被完整的揭露出来，而在编译期间不需要知道任何东西。

大家要认识的很重要的一点是“反射”并没有什么神奇的地方。通过“反射”同一个未知类型的对象打交道时，JVM只是简单地检查那个对象，并调查它从属于哪个特定的类（就象以前的RTTI那样）。但在这之后，在我们做其他任何事情之前，Class对象必须载入。因此，用于那种特定类型的.class文件必须能由JVM调用（要么在本地机器内，要么可以通过网络取得）。所以RTTI和“反射”之间唯一的区别就是对RTTI来说，编译器会在编译期打开和检查.class文件。换句话说，我们可以用“普通”方式调用一个对象的所有方法；但对“反射”来说，.class文件在编译期间是不可使用的，而是由运行期环境打开和检查。

11.3.1 一个类方法提取器

很少需要直接使用反射工具；之所以在语言中提供它们，仅仅是为了支持其他Java特性，比如对象序列化（第10章介绍）、Java Beans以及RMI（本章后面介绍）。但是，我们许多时候仍然需要动态提取与一个类有关的资料。其中特别有用的工具便是一个类方法提取器。正如前面指出的那样，若检视类定义源码或者联机文档，只能看到在那个类定义中被定义或覆盖的方法，基类那里还有大量资料拿不到。幸运的是，“反射”做到了这一点，可用它写一个简单的工具，令其自动展示整个接口。下面便是具体的程序：

  1. //: ShowMethods.java
  2. // Using Java 1.1 reflection to show all the
  3. // methods of a class, even if the methods are
  4. // defined in the base class.
  5. import java.lang.reflect.*;
  7. public class ShowMethods {
  8.   static final String usage =
  9.     "usage: \n" +
  10.     "ShowMethods qualified.class.name\n" +
  11.     "To show all methods in class or: \n" +
  12.     "ShowMethods qualified.class.name word\n" +
  13.     "To search for methods involving 'word'";
  14.   public static void main(String[] args) {
  15.     if(args.length < 1) {
  16.       System.out.println(usage);
  17.       System.exit(0);
  18.     }
  19.     try {
  20.       Class c = Class.forName(args[0]);
  21.       Method[] m = c.getMethods();
  22.       Constructor[] ctor = c.getConstructors();
  23.       if(args.length == 1) {
  24.         for (int i = 0; i < m.length; i++)
  25.           System.out.println(m[i].toString());
  26.         for (int i = 0; i < ctor.length; i++)
  27.           System.out.println(ctor[i].toString());
  28.       }
  29.       else {
  30.         for (int i = 0; i < m.length; i++)
  31.           if(m[i].toString()
  32.              .indexOf(args[1])!= -1)
  33.             System.out.println(m[i].toString());
  34.         for (int i = 0; i < ctor.length; i++)
  35.           if(ctor[i].toString()
  36.              .indexOf(args[1])!= -1)
  37.           System.out.println(ctor[i].toString());
  38.       }
  39.     } catch (ClassNotFoundException e) {
  40.       System.out.println("No such class: " + e);
  41.     }
  42.   }
  43. } ///:~

Class方法getMethods()和getConstructors()可以分别返回Method和Constructor的一个数组。每个类都提供了进一步的方法，可解析出它们所代表的方法的名字、参数以及返回值。但也可以象这样一样只使用toString()，生成一个含有完整方法签名的字符串。代码剩余的部分只是用于提取命令行信息，判断特定的签名是否与我们的目标字符串相符（使用indexOf()），并打印出结果。

这里便用到了“反射”技术，因为由Class.forName()产生的结果不能在编译期间获知，所以所有方法签名信息都会在运行期间提取。若研究一下联机文档中关于“反射”（Reflection）的那部分文字，就会发现它已提供了足够多的支持，可对一个编译期完全未知的对象进行实际的设置以及发出方法调用。同样地，这也属于几乎完全不用我们操心的一个步骤——Java自己会利用这种支持，所以程序设计环境能够控制Java Beans——但它无论如何都是非常有趣的。

一个有趣的试验是运行java ShowMehods ShowMethods。这样做可得到一个列表，其中包括一个public默认构造器，尽管我们在代码中看见并没有定义一个构造器。我们看到的是由编译器自动生成的那一个构造器。如果随之将ShowMethods设为一个非public类（即换成“友好”类），生成的默认构造器便不会在输出结果中出现。生成的默认构造器会自动获得与类一样的访问权限。
ShowMethods的输出仍然有些“不爽”。例如，下面是通过调用java ShowMethods java.lang.String得到的输出结果的一部分：

  1. public boolean
  2.   java.lang.String.startsWith(java.lang.String,int)
  3. public boolean
  4.   java.lang.String.startsWith(java.lang.String)
  5. public boolean
  6.   java.lang.String.endsWith(java.lang.String)

若能去掉象java.lang这样的限定词，结果显然会更令人满意。有鉴于此，可引入上一章介绍的StreamTokenizer类，解决这个问题：

  1. //: ShowMethodsClean.java
  2. // ShowMethods with the qualifiers stripped
  3. // to make the results easier to read
  4. import java.lang.reflect.*;
  5. import java.io.*;
  7. public class ShowMethodsClean {
  8.   static final String usage =
  9.     "usage: \n" +
  10.     "ShowMethodsClean qualified.class.name\n" +
  11.     "To show all methods in class or: \n" +
  12.     "ShowMethodsClean qualif.class.name word\n" +
  13.     "To search for methods involving 'word'";
  14.   public static void main(String[] args) {
  15.     if(args.length < 1) {
  16.       System.out.println(usage);
  17.       System.exit(0);
  18.     }
  19.     try {
  20.       Class c = Class.forName(args[0]);
  21.       Method[] m = c.getMethods();
  22.       Constructor[] ctor = c.getConstructors();
  23.       // Convert to an array of cleaned Strings:
  24.       String[] n =
  25.         new String[m.length + ctor.length];
  26.       for(int i = 0; i < m.length; i++) {
  27.         String s = m[i].toString();
  28.         n[i] = StripQualifiers.strip(s);
  29.       }
  30.       for(int i = 0; i < ctor.length; i++) {
  31.         String s = ctor[i].toString();
  32.         n[i + m.length] =
  33.           StripQualifiers.strip(s);
  34.       }
  35.       if(args.length == 1)
  36.         for (int i = 0; i < n.length; i++)
  37.           System.out.println(n[i]);
  38.       else
  39.         for (int i = 0; i < n.length; i++)
  40.           if(n[i].indexOf(args[1])!= -1)
  41.             System.out.println(n[i]);
  42.     } catch (ClassNotFoundException e) {
  43.       System.out.println("No such class: " + e);
  44.     }
  45.   }
  46. }
  48. class StripQualifiers {
  49.   private StreamTokenizer st;
  50.   public StripQualifiers(String qualified) {
  51.       st = new StreamTokenizer(
  52.         new StringReader(qualified));
  53.       st.ordinaryChar(' '); // Keep the spaces
  54.   }
  55.   public String getNext() {
  56.     String s = null;
  57.     try {
  58.       if(st.nextToken() !=
  59.             StreamTokenizer.TT_EOF) {
  60.         switch(st.ttype) {
  61.           case StreamTokenizer.TT_EOL:
  62.             s = null;
  63.             break;
  64.           case StreamTokenizer.TT_NUMBER:
  65.             s = Double.toString(st.nval);
  66.             break;
  67.           case StreamTokenizer.TT_WORD:
  68.             s = new String(st.sval);
  69.             break;
  70.           default: // single character in ttype
  71.             s = String.valueOf((char)st.ttype);
  72.         }
  73.       }
  74.     } catch(IOException e) {
  75.       System.out.println(e);
  76.     }
  77.     return s;
  78.   }
  79.   public static String strip(String qualified) {
  80.     StripQualifiers sq =
  81.       new StripQualifiers(qualified);
  82.     String s = "", si;
  83.     while((si = sq.getNext()) != null) {
  84.       int lastDot = si.lastIndexOf('.');
  85.       if(lastDot != -1)
  86.         si = si.substring(lastDot + 1);
  87.       s += si;
  88.     }
  89.     return s;
  90.   }
  91. } ///:~

ShowMethodsClean方法非常接近前一个ShowMethods，只是它取得了Method和Constructor数组，并将它们转换成单个String数组。随后，每个这样的String对象都在StripQualifiers.Strip()里“过”一遍，删除所有方法限定词。正如大家看到的那样，此时用到了StreamTokenizer和String来完成这个工作。

假如记不得一个类是否有一个特定的方法，而且不想在联机文档里逐步检查类结构，或者不知道那个类是否能对某个对象（如Color对象）做某件事情，该工具便可节省大量编程时间。

第17章提供了这个程序的一个GUI版本，可在自己写代码的时候运行它，以便快速查找需要的东西。