内嵌类简介知识 _ 路由器设置|192.168.1.1|无线路由器设置|192.168.0.1

内嵌类简介知识

用内嵌类减少JAVA 程序设计中的混乱

孙国泉编译

摘要：JDK1.1 中最有争议的变化也许就是引入了“ 内嵌类”。争议的根源在于大多数人认为内嵌类将改变JAVA 语言，使其变得臃肿。然而，我认为内嵌类是对JAVA 语言的有效改变，并且对现存的JAVA 虚拟机没有任何影响。

在1996 年12 月那期名为“ 总述” 的专栏中，我讨论了在JAVA 中构造一般集合类的困难。之后发生了两件事：一，SUN 建立了内嵌类以帮助实现JAVA BEANS；二，SUN 为JAVA 提出了一个基本的集合类。我赞同SUN 的提议，但我希望SUN 能提供进行强类型检查的方法。强类型检查是一种确保放到某个集合中的对象是同类型的机制。目前，这些集合把Object 类当作基本的引用，如果你由于你的类中的错误把某个非法的类存入集合，那么当你从集合中搜索存好的引用时，上述引用就会产生类强制性异常。作为提供类型强制的类的一个例子，参看下面“ 资源” 部分中的“ContainerOrganizer” 类。

1 什么是内嵌类

内嵌类是些类文件，它们的名字被“ 限定” 在另一个类内。所谓的“ 限定” 就是定义了它什么时候能被JAVA 代码引用。当两个类共享一个包时，它们就有“ 包限定”。除非包被定义为公用包，否则包外的类不能引用其中的类。这样类名就限定在包中。

内嵌类被限定在说明它们的类中，实际上对同一个包中的其他类是不可见的。这种对包中其他类的屏蔽使程序员能在包含类中建立类集，同时不会弄乱包中的命名空间。

根据SUN 公司的文挡，SUN 的工程师们认为内嵌类解决了JAVA 定义中的一个问题，即：JAVA 类只能被定义为与别的类同等的类。内嵌类首先改变了编译器，为了支持与现存虚拟机的向后兼容，内嵌类实际上被编译成正常的类文件，只是改变了名字以防止与已有的类相冲突。

为支持内嵌类，在JAVA 中对应该在程序的何处说明类的有关规定作了修改。如果你在JAVA1.0X 中编过程序，你就会知道能在单个源文件中定义多个类（只要其中一个类是公共的），并且第二个以及随后的类必须紧跟在第一个类的花括号后面。在1.1 中这些都改变了：现在你可以在另一个类内声明类。下面的例子说明得更清楚。在JAVA1.0 中你必须象下面所示的代码一样在一个文件中连续地声明两个类：

 public class MyPublicClass {
  public MyPublicClass() { ... }
  void method1() { ... }
  int method2() { ... }
  public method3(int x, int y) { ... }
  }

上面的类是存放在MyPublicClass.java 文件中的“ 基本类”（base class）。它在method3 方法中需要别的类帮助它完成某些功能。一般这个类也在同一个文件中定义，下面即是一例：

  class MyHelperClass {
  MyHelperClass() { ... }
  int someHelperMethod(int z, int q) { ... }
  }

同一个文件中的类在某些方面通常是相互关联的。例如，我们在BinarySearchTree 类中建立了BSTEnumerator 类，它提供了一种返回二进制搜索树中所有元素（或键）的方法。在Dictionary 类的子类，如Hashtable 中, 通常是把这些类组合到一个文件中。

有了内嵌类，你可以用如下的代码说明类：

  public class MyPublicClass {
    public MyPublicClass() { ... }
    class MyHelperClass {
      MyHelperClass() { ... }
      int someHelperMethod(int z, int q) { ... }
    }
    void method1() { ... }
    int method2() { ... }
    public method3(int x, int y) { ... }
  }

你可以看到，这只涉及到一些文本的变化。然而，内嵌类的出现是很有意义的。

上面例子中的内嵌类是MyHelperClass, 但在第一种情况下有两个类（也许在默认的包中）：MyPublicClass 类和 MyHelperClass 类。在第二个例子中仍有两个类，除了MypublicClass 类以外，另一个类映象为MyPublicClass$MyHelperClass。这样做的好处是建立了新的命名空间，它只有帮助类的名字。在前一个例子中，基本类和帮助类都占用了命名空间，有了内嵌类后，帮助类得到了一个完全属于它自己的命名空间。

2 如何使用内嵌类

我们以 BinarySearchTree 类来说明内嵌类的使用。

  import java.io.PrintStream;
  import java.util.Enumeration;
  import java.util.NoSuchElementException;
  import java.util.Dictionary;

  public class BinarySearchTree extends Dictionary {
  BSTNode rootNode;
  private int elementCount;
  private ContainerOrganizer co;

   /**
   * Define an inner class to be the enumerator
   */

  class BSTEnumerator implements Enumeration {
    private BSTNode currentNode;
    private boolean keys;
    BSTEnumerator(BSTNode start, boolean doKeys) {
      super();
      currentNode = (start != null) ? start.min() : null;
      keys = doKeys;
    }

    public boolean hasMoreElements() {
      return (currentNode != null);
    }

    public Object nextElement() {
      if (currentNode == null)
        throw new NoSuchElementException();
      BSTNode n = currentNode;
      currentNode = n.successor();
      return (keys ? n.key : n.payload);
    }
  }

当在JDK1.1 中编译上面的类时，编译器建立两个类文件：BinarySearchTree.class 类文件和BinarySearchTree$BSTEnumerator.class 类文件。注意类名中有“$” 字符，它把内嵌类从包含它的基本类中区别开来。在内嵌类BSTEnumerator 的定义后继续定义BinarySearchTree：

 public BinarySearchTree(ContainerOrganizer c) {
    super();
    co = c;
    co.setDict(this);
   }
    ... and so on for the rest of the class ...
  }

使用这种形式的内嵌类的主要价值是能建立特别指定的枚举类，并且不会在包这一级弄乱命名空间。考虑到集合类组成的包可能有许多不同的基于行为的返回值（如枚举，有序列表，固定的等等），具体的类的数目可能很大。许多名字以前只需一个单一的值。当然完全可以用手工来完成这些命名空间的维护工作，实际效果和内嵌类一样；这也就是为什么SUN 声明它只是编译器中的语法修饰。

3 一种内嵌类：匿名类

当你只是想传递一个做些事情的方法时你甚至不需名字（类似于C 语言的回调函数），你只需建立一个匿名的内嵌类。这些类只是没有具体名字的内嵌类。只用一次的类一般不命名。

为说明匿名类，我们编写了 BinarySearchTree 的 keys 和 elements 方法，它们都用来返回一个BSTEnumerator 对象，如下所示。

  private Enumeration doEnumerate(final boolean k) {
    return new Enumeration() { 
      private BSTNode currentNode = rootNode;
      private boolean keys = k;
      public boolean hasMoreElements() {
        return (currentNode != null);
      }
      public Object nextElement() {
        if (currentNode == null)
          throw new NoSuchElementException();
        BSTNode n = currentNode;
        currentNode = n.successor();
        return (keys ? n.key : n.payload);
      }
    };
  }

  public Enumeration elements() {
    return doEnumerate(false);
  }

  public Enumeration keys() {
    return doEnumerate(true);
  }

仔细看一下doEnumerate 函数；有两样事情比较奇怪。第一，它返回接口的新的实例；其次，它前面的参数k 是final 型的。到底是怎么回事呢？答案是这种技术是使用内嵌类的又一方法。

返回说明看起来是建立了一个新的接口实例，但事实上是建立了一个没有明确名字并且实现了接口的新类。在这种情况下，实际上的名字是BinarySearchTree$1，但它只对编译器的作者有意义。

用这种方法建立类的一个局限是，新的类不能定义构造操作（记住：它没有名字），因此在类中必须有办法设置初始状态。JAVA1.1 的办法是重新定义对非类变量的操作。尤其是现在能合法地把它们象静态变量一样初始化，却不用把它们放在静态初始化块中。这对程序员来说意味着你能说明非静态的并且预先初始化的实例的值，例如“int foo=10;”。

当然，当你创建内嵌类时，一般你喜欢从包含在enclosing 类的信息中初始化内嵌类。（在例子中，BinarySearchTree 就是包容类。）这是通过这样一些规则完成的：如果说明在定义类的地方，那么内嵌类能访问所说明所有的字段（变量）。这样在上例中，初始化“currentNode=rootNode” 是指包容类变量中的实例变量rootNode。

在上面的匿名类中有第二个初始化：“keys=k;”。C 程序员看到它立即会警觉告：“ 你在使用返回值堆栈中的值！” 注意，k 在这段代码中是正式与doEnumerate 相关的参数。这就是“final” 关键字新语义的原因所在。

在JAVA 语言中，变量的final 属性的含义是，它的值只能分配一次。因此，一旦分配了后，final 变量的值就不能再变。在上面的例子中编译器可以安全地把k 的值拷贝到固定的存储区中。

JAVA 是“ 值调用” 语言，意思是方法的所有参数都有值，值的改变不会影响该值的调用方法拷贝。如果将对象引用也作为值来对待，这种语义就显得有些模糊，并且如果传递了对象的值后又修改了它，所有有同样引用的类都会找到修改后的对象。虽然这看起来有些混乱，但JAVA 的语义实际是一致的。

匿名内嵌类有这样一个问题：当k 的值改变时随着k 的分配会有什么变化？考虑一下下面这段混乱的代码：

   private Enumeration doEnumerate(boolean k) {
    Enumeration ee = new Enumeration() { 
      private BSTNode currentNode = rootNode;
      private boolean keys = k;
      public boolean hasMoreElements() { ... }
      public Object nextElement() { ... }
    };
    k = !k;
    return ee;
  }

上面k 的值在返回ee 之前被修改。虽然现在能等到需要时再建立对象实例，但如何确定使用了哪个k 值？是执行new 时的k 值，还是执行return 时的k 值？回答是你没法确定，因而JAVA 软件工程师们规定k 的值必须声明为final，编译器就会强制k 的值不变。当k 的值被说明为final 后，编译器就会忽略改变其值的说明，决定k 值的语义就不再是模棱两可的了。

4 关于“this”

当你写JAVA 代码时，有时不可避免地要明确地引用定义为目前对象实例的实例变量。你解决的办法是在变量名前加一个“this” 限定词。this.x 这个名字就是指对象的this 实例中的变量名。很显然，如果你在内嵌类中引用this，它是指内嵌类本身所定义的域或变量。然而，我们刚刚解决了使用包容类 — —rootNode — — 的实例变量的声明，如果我们只需在内嵌类中定义一个名字也是rootNode 的变量，我们如何区分它们呢？答案是还有另外一个新的this: qualified this。

关于this 关键词有一个限定词。该限定词的定义是你可用任何一个包容类的名字作为this 的限定词。在我们假设的定义其自己的rootNode 域的内嵌类这一例子中，内嵌类的值通常是this.rootNode，包容类中的值能用BinarySearchTree.this.rootNode 来调用。你可以看到这个名字始终明确，因为JAVA1.1 新规定内嵌类不能与它的任何一个包容类同名。

你很容易搞混到底在引用哪个类变量，我建议你保持你的实例变量有明确的名字。幸运的是，只有编译器的设计者才必须知道给本身是匿名内嵌类的包容类中的实例变量取了什么名字。

5 另外一些要考虑的问题

JAVA 语言新用户们经常碰到的问题是缺乏JAVA 方法调用的引用传递语义。解决如何获得引用传递语义这一问题的方法是建立指向一个可设置的，并且以后可以检索的值的类。这样做通常很麻烦，因为必须建立一个完整的类才能从方法调用中返回多个值。

考虑一下下面这段代码中内嵌类是如何解决这个问题的：

  public class PointSample {
  public void samplePoint(IntSetter x, IntSetter y, FloatSetter m) {
    x.set(10);
    y.set(100);
    m.set(5.5f);
   }
  }

上面的代码要返回三个值：x,y, 和m。因此我们没有传递局部类型，而是用IntSetter 或FloatSetter 类型的对象引用。IntSetter 的定义如下：

  public interface IntSetter {
   public void set(int value);
   }

你可以看到，这只是定义了set 方法的接口，该方法选取一个整数值并把它设置好。FloatSetter 的设计留给读者作练习。现在考虑一下下面的程序例子：

 public class example {
  int     xPos = 0, yPos = 0;
  float    magnitude = 1.0f;
  public void doit() {
   PointSample ps = new PointSample();
   System.out.println("Shows off an anonymous inner class.");
   System.out.println("X,Y = ["+xPos+", "+yPos+"], Mag = "+magnitude);
   ps.samplePoint(new IntSetter() {public void set(int a) { xPos = a; }},
     new IntSetter() { public void set(int a) { yPos = a; }},
     new FloatSetter() { public void set(float a) { magnitude = a;}});
   System.out.println("X,Y = ["+xPos+", "+yPos+"], Mag = "+magnitude);
 }

 public static void main(String args[]) {
   example ex = new example();
   ex.doit();
  }
 }

main 方法所做的是建立example 对象的一个实例，并且调用其中的doit 方法。 doit 方法更有趣：它建立了一个PointSample 对象，并用三个内嵌类调用其samplePoint 方法。

内嵌类的实现允许起用samplePoint 方法简单地把结果存到调用类（这儿是example）的实例变量中。这项技术省去了返回含有值的类的中间步骤，它把类中的值去除，并存到实例变量中。这个例子中实现的功能有点象引用传递，用JAVA 的术语来说意思是它传递了一个能改变引用对象的状态的操作。一旦你掌握了它的诀窍后，你会发现内嵌类带来了无穷无尽的可能性。

6 结束语

内嵌类使JAVA 语言可以清晰地表达程序员的意图而不会增加混乱。因为它们是在编译器中实现的，内嵌类在技术上并不代表对JAVA（TM）平台的改变，但它们肯定改变了JAVA 语言。当内嵌类与Core Reflection API 组合在一起时，它们能使我们建立动态链接的回调机制。AWT 中新的事件模块是这种机制的一个很好的例子。

本文地址：http://www.45fan.com/dnjc/71173.html

php和java的区别	在eclipse中批量修改java文件编码的方法
在IE浏览器中调试JavaScript程序的方法	javascript正则表达式集锦
解决vs2005编译时出现C2859错误的方法技	处理win7系统启动Zend Studio弹出Failed
解决MyEclipse8.5导入java项目后会出现红	VC操作编译的基础问题的方法
调用ASP+JAVASCRIPT的数据库的步骤	在Java中将long格式化成网卡地址的步骤

45fan.com - 路饭网

内嵌类简介知识

用内嵌类减少JAVA 程序设计中的混乱

Tags： Java 编译孙国泉

45fan.com - 路饭网

内嵌类简介知识

用 内 嵌 类 减 少JAVA 程 序 设 计 中 的 混 乱

Tags： Java 编译 孙国泉

用内嵌类减少JAVA 程序设计中的混乱

Tags： Java 编译孙国泉