链接到外部类

核心提示：迄今为止，我们见到的内部类好象仅仅是一种名字隐藏以及代码组织方案，链接到外部类，尽管这些功能非常有用，但似乎并不非凡引人注目，编译器就会报错，进行所有这些操作的时候，然而，我们还忽略了另一个重要的事实

　　迄今为止，我们见到的内部类好象仅仅是一种名字隐藏以及代码组织方案。尽管这些功能非常有用，但似乎并不非凡引人注目。然而，我们还忽略了另一个重要的事实。创建自己的内部类时，那个类的对象同时拥有指向封装对象（这些对象封装或生成了内部类）的一个链接。所以它们能访问那个封装对象的成员——毋需取得任何资格。除此以外，内部类拥有对封装类所有元素的访问权限（注释②）。下面这个例子阐示了这个问题：
　　
　　//: Sequence.java
　　// Holds a sequence of Objects
　　
　　interface Selector {
　　　boolean end();
　　　Object current();
　　　void next();
　　}
　　
　　public class Sequence {
　　　PRivate Object[] o;
　　　private int next = 0;
　　　public Sequence(int size) {
　　　　o = new Object[size];
　　　}
　　　public void add(Object x) {
　　　　if(next < o.length) {
　　　　　o[next] = x;
　　　　　next++;
　　　　}
　　　}
　　　private class SSelector implements Selector {
　　　　int i = 0;
　　　　public boolean end() {
　　　　　return i == o.length;
　　　　}
　　　　public Object current() {
　　　　　return o[i];
　　　　}
　　　　public void next() {
　　　　　if(i < o.length) i++;
　　　　}
　　　}
　　　public Selector getSelector() {
　　　　return new SSelector();
　　　}
　　　public static void main(String[] args) {
　　　　Sequence s = new Sequence(10);
　　　　for(int i = 0; i < 10; i++)
　　　　　s.add(Integer.toString(i));
　　　　Selector sl = s.getSelector();　　
　　　　while(!sl.end()) {
　　　　　System.out.println((String)sl.current());
　　　　　sl.next();
　　　　}
　　　}
　　} ///:~
　　
　　②：这与C++“嵌套类”的设计颇有不同，后者只是一种单纯的名字隐藏机制。在C++中，没有指向一个封装对象的链接，也不存在默认的访问权限。
　　
　　其中，Sequence只是一个大小固定的对象数组，有一个类将其封装在内部。我们调用add()，以便将一个新对象添加到Sequence末尾（假如还有地方的话）。为了取得Sequence中的每一个对象，要使用一个名为Selector的接口，它使我们能够知道自己是否位于最末尾（end()），能观看当前对象（current() Object），以及能够移至Sequence内的下一个对象（next() Object）。由于Selector是一个接口，所以其他许多类都能用它们自己的方式实现接口，而且许多方法都能将接口作为一个自变量使用，从而创建一般的代码。
　　
　　在这里，SSelector是一个私有类，它提供了Selector功能。在main()中，大家可看到Sequence的创建过程，在它后面是一系列字串对象的添加。随后，通过对getSelector()的一个调用生成一个Selector。并用它在Sequence中移动，同时选择每一个项目。
　　
　　从表面看，SSelector似乎只是另一个内部类。但不要被表面现象迷惑。请注重观察end()，current()以及next()，它们每个方法都引用了o。o是个不属于SSelector一部分的句柄，而是位于封装类里的一个private字段。然而，内部类可以从封装类访问方法与字段，就象已经拥有了它们一样。这一特征对我们来说是非常方便的，就象在上面的例子中看到的那样。
　　
　　因此，我们现在知道一个内部类可以访问封装类的成员。这是如何实现的呢？内部类必须拥有对封装类的特定对象的一个引用，而封装类的作用就是创建这个内部类。随后，当我们引用封装类的一个成员时，就利用那个（隐藏）的引用来选择那个成员。幸运的是，编译器会帮助我们照管所有这些细节。但我们现在也可以理解内部类的一个对象只能与封装类的一个对象联合创建。在这个创建过程中，要求对封装类对象的句柄进行初始化。若不能访问那个句柄，编译器就会报错。进行所有这些操作的时候，大多数时候都不要求程序员的任何介入。