Java 版 (精华区)

发信人: angle (finder), 信区: Java
标  题: 内 嵌 类 简 介(1)
发信站: 哈工大紫丁香 (Sun Jun 20 20:20:50 1999), 转信

 

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



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

      我 希 望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。 这 样 做 的 好 处 是 建 立 了 新 的 命 名 空 间
 它 只有 帮 助 类 的 名 字。 在 前 一 个 例 子 中， 基 本 类 和 
帮 助 类 都 占 用 了命 名 空 间，
 有 了 内 嵌 类 后， 帮 助 类 得 到 了 一 个 完 全 属 于 它 自 己
 的 命 名 空 间。

--
☆ 来源:．哈工大紫丁香 bbs.hit.edu.cn．[FROM: www-post@bbs.hit.edu]