尽 管 Java 语 言 是 在 C++ 语 言 基 础 上 发 展 起 来 的, 但 与 C++ 不 同,Java 是 一 种 纯 粹 的 面 向 对 象 语 言 (Object-oriented language) 在 Java 世 界 中, 所 有 事 物 都 是 Object 1. 通 过

玩 转 Object 不 理 解, 就 无 法 真 正 拥 有 歌 德 按 其 实 而 审 其 名, 以 求 其 情 ; 听 其 言 而 查 其 累, 无 使 放 悖 ( 根 据 实 际 明 辨 名 称, 以 便 求 得 真 实 情 况 ; 听 取 言 辞 后 弄 明 它 的 类 别, 不 让 它 混 淆 错 乱 ) 三 玩 转 Object 大 围 山 人 玩 转 Object...1 1. 通 过 引 用 (reference) 来 使 用 Object... 2 2. 必 须 创 建 (create) 所 有 的 Object... 3 计 算 机 存 储 系 统... 3 特 例 : 基 本 数 据 类 型 (primitive types)... 3 3. 没 有 必 要 销 毁 (destroy/delete)object... 4 变 量 的 作 用 域 (Scoping)... 4 Object 的 作 用 域...5 4. 生 成 新 的 数 据 类 型... 5 数 据 成 员 与 方 法... 6 方 法 形 式 参 数 返 回 值... 8 形 式 参 数 清 单... 8 static 关 键 词... 9 5. 注 释 与 嵌 入 式 文 档... 10 注 释 文 档... 10 注 释 文 档 的 语 法... 11 嵌 入 HTML... 12 常 见 的 标 签... 12 6.Java 编 程 格 式... 13

尽 管 Java 语 言 是 在 C++ 语 言 基 础 上 发 展 起 来 的, 但 与 C++ 不 同,Java 是 一 种 纯 粹 的 面 向 对 象 语 言 (Object-oriented language) 在 Java 世 界 中, 所 有 事 物 都 是 Object 1. 通 过 引 用 (reference) 来 使 用 Object 在 java 语 言 中, 我 们 通 过 Object 描 述 所 有 事 物 而 我 们 通 过 Object 的 引 用 来 使 用 / 操 纵 Object 可 以 将 被 操 纵 的 Object 想 象 为 一 台 电 视 机, 而 我 们 用 来 操 纵 这 个 Object 的 引 用 (reference) 就 是 电 视 遥 控 器 只 要 手 里 拿 着 电 视 遥 控 器, 我 们 就 拥 有 与 电 视 机 的 连 接 当 需 要 改 变 频 道 或 设 定 电 视 机 的 声 音 时, 我 们 实 际 上 操 作 的 是 电 视 遥 控 器 ( 亦 即 引 用 ); 当 希 望 在 家 里 走 动 的 同 时, 还 能 够 控 制 电 视 机 时, 我 们 拿 在 手 里 的 是 电 视 遥 控 器 ( 引 用 ), 而 不 是 电 视 机 本 身 值 得 注 意 的 是, 没 有 电 视 机, 电 视 遥 控 器 也 能 够 独 立 存 在 同 样 有 一 个 引 用 并 不 意 味 着 就 拥 有 一 个 Object 声 明 一 个 字 符 串, 来 存 储 一 个 句 子 或 单 词, 格 式 如 下 : String s; 但 是 这 时 我 们 只 是 声 明 了 一 个 引 用, 而 不 是 一 个 Object 如 果 此 时 向 s 发 出 一 个 消 息 / 请 求, 在 程 序 运 行 时 会 产 生 一 个 错 误 1, 因 为 此 时 引 用 s 没 有 指 向 任 何 Object( 我 们 只 有 遥 控 器, 而 没 有 接 受 该 遥 控 器 控 制 的 电 视 机 ) 比 较 安 全 的 做 法 是, 每 当 创 建 ( 声 明 ) 一 个 引 用 时, 及 时 初 始 化 ( 及 时 建 立 它 与 Object 之 间 的 联 系 ) String s = asdf ; 1 如 果 s 是 自 动 变 量 或 局 部 变 量 ( 指 定 义 在 某 个 局 部 范 围 或 方 法 内 部 的 变 量 ), 那 么 在 编 译 时 编 译 器 会 发 现 错 误, 编 译 器 会 告 诉 我 们 变 量 s 没 有 被 妥 善 初 始 化 如 果 s 是 某 个 类 的 数 据 成 员, 那 么 程 序 在 运 行 时 产 生 错 误, 因 为 类 的 数 据 成 员 被 自 动 初 始 化 为 缺 省 值 : 引 用 的 缺 省 值 是 null, 而 向 null 发 送 信 息 就 会 产 生 错 误

在 这 里 我 们 使 用 了 Java 语 言 的 一 种 特 殊 功 能 : 字 符 串 对 象 可 以 直 接 用 带 引 号 的 字 符 串 初 始 化 而 对 于 一 般 的 情 况, 我 们 必 须 使 用 通 用 的 初 始 化 过 程 2. 必 须 创 建 (create) 所 有 的 Object 如 何 创 建 一 个 Object? 我 们 一 般 使 用 运 算 符 new 来 创 建 一 个 对 象, 运 算 符 new 后 面 跟 着 的 是 类 的 构 造 方 法 new 意 味 着 生 成 该 类 的 一 个 新 的 实 体 所 以, 生 成 一 个 字 符 串 的 更 加 通 用 的 做 法 是 String s = new String( asdf ); 这 句 话 的 意 思 是 : 生 成 一 个 内 容 为 asdf 的 字 符 串 对 象 (Object) Java 标 准 库 提 供 了 大 量 的 类, 如 今 java.lang.string,java.lang.system 等 此 外 我 们 也 可 以 编 写 自 己 的 类, 如 HelloJava 实 际 上, 编 写 类 是 用 Java 语 言 开 发 程 序 的 最 主 要 的 工 作, 也 是 我 们 课 程 讲 述 的 主 要 内 容 为 了 理 解 Java 的 对 象 管 理 机 制, 我 们 有 必 要 了 解 计 算 机 的 存 储 系 统 计 算 机 存 储 系 统 当 计 算 机 程 序 运 行 时, 有 六 种 不 同 的 地 方 可 以 存 储 信 息 : 1. 寄 存 器 (Register): 寄 存 器 位 于 CPU 内 部, 是 计 算 机 系 统 中 运 行 速 度 最 快 的 一 种 存 储, 但 是 存 储 器 的 数 量 有 限, 所 以, 存 储 器 的 使 用 由 程 序 编 译 器 根 据 实 际 情 况 决 定, 编 程 人 员 一 般 不 能 直 接 控 制 他 们 的 使 用 2. 堆 栈 (Stack): 从 通 用 随 机 访 问 内 存 (RAM:Random Access Memory) 中 获 得 的 专 用 存 储 空 间 其 地 址 由 CPU 中 的 堆 栈 指 针 寄 存 器 直 接 管 理, 通 过 堆 栈 指 针 向 下 移 动 来 获 得 空 间, 而 通 过 堆 栈 指 针 向 上 移 动 来 释 放 空 间, 所 以 其 运 行 速 度 快 于 其 他 通 用 RAM Java 语 言 中 的 基 本 数 据 类 数 据 对 象 的 引 用 等 存 储 在 堆 栈 之 中, 对 象 本 身 并 不 存 储 在 堆 栈 之 中, 而 是 存 储 在 堆 中 3. 堆 (Heap): 这 是 公 用 的 通 用 RAM 存 储 Java 语 言 将 所 有 对 象 存 储 在 堆 之 中 每

当 需 要 生 成 新 的 对 象 时, 我 们 通 过 运 算 符 new 来 申 请 空 间 堆 用 起 来 很 方 便, 但 是 与 堆 栈 相 比, 运 行 速 度 比 较 慢 4. 静 态 存 储 (Static Storage): 静 态 存 储 空 间 也 位 于 通 用 RAM 之 中, 但 是 静 态 存 储 变 量 的 地 址 终 生 保 持 不 变 我 们 可 以 通 过 申 明 某 个 数 据 成 员 为 静 态, 使 他 们 的 地 址 终 生 不 变 5. 常 量 存 储 (Constant Storage): 常 量 通 常 与 程 序 本 身 存 储 在 一 起 6. 非 内 存 存 储 (Non-RAM Storage): 如 果 数 据 可 完 全 脱 离 程 序 存 在, 他 们 往 往 以 文 件 或 数 据 库 的 形 式 存 在 这 是 运 行 速 度 最 慢 的 存 储, 但 是 其 容 量 基 本 不 受 限 制 Java 的 Object 通 过 运 算 符 new 生 成, 全 部 存 储 在 堆 中 例 外 : 基 本 数 据 类 型 (primitive types) Java 的 基 本 数 据 类 型 boolean, char, byte, short, int, long, float, double 等 类 型 的 数 据 不 通 过 new 生 成 这 些 数 据 存 储 在 堆 栈 中 Java 中 使 用 的 基 本 数 据 类 型, 以 及 他 们 的 尺 寸, 取 值 范 围, 和 包 装 类 如 下 表 所 示 : 基 本 数 据 类 型 尺 寸 最 小 值 最 大 值 包 装 类 boolean - - - Boolean char 16-bit Unicode 0 Unicode 2^16-1 byte 8-bit -128 127 Byte Character short 16-bit -2^15 2^15-1 Short int 32-bit -2^31 2^31-1 Integer long 64-bit -2^63 2^63-1 Long float 32-bit IEEE754 IEEE754 Float double 64-bit IEEE754 IEEE754 Double void - - - Void 包 装 类 (Wrapper classes) 存 在 的 目 的 是 容 许 我 们 像 操 纵 一 般 对 象 那 样 操 纵 基 本 数 据 类 型 的 数 据

3. 没 有 必 要 销 毁 (destroy/delete)object 在 大 多 数 编 程 语 言 中, 变 量 的 生 命 期 是 困 扰 编 程 人 员 的 一 大 问 题 : 一 个 变 量 需 要 生 存 多 长 时 间? 如 果 你 必 须 负 责 销 毁 它, 以 达 到 释 放 内 存 的 目 的, 那 么 什 么 时 候 销 毁? 在 C 和 C++ 语 言 中, 因 为 需 要 编 程 人 员 负 责 将 变 量 所 占 据 的 内 存 归 还 给 系 统, 变 量 的 销 毁 问 题 变 成 了 编 程 人 员 的 一 大 负 担 经 常 会 因 为 编 程 人 员 忘 记 了 销 毁 变 量 而 导 致 内 存 枯 竭, 系 统 瘫 痪 而 Java 语 言 中 对 象 所 占 据 的 内 存 有 系 统 负 责 自 动 释 放 所 以 用 Java 语 言 编 写 的 软 件 系 统 绝 对 不 会 发 生 由 于 内 存 枯 竭 而 导 致 系 统 瘫 痪 的 情 况 基 本 数 据 类 型 变 量 的 作 用 域 (Scoping) 如 同 C 和 C++ 语 言 一 样,Java 语 言 中 变 量 的 作 用 域 由 花 括 号 { 控 制 比 如 { int x = 12; // 只 有 变 量 x 可 用 { int q = 96; // 此 时 变 量 x 和 q 均 可 使 用 // 只 有 变 量 x 可 用, 此 时 已 经 超 出 变 量 q 的 作 用 域 如 上 述 例 子 所 示, 在 一 个 范 围 / 作 用 域 内 定 义 的 变 量 只 在 那 个 作 用 域 内 存 在 { int x = 12; { int x = 96; // 语 法 错 误! 上 述 代 码 在 C 和 C++ 中 是 合 法 的, 但 是 在 Java 中 则 是 语 法 错 误 Object 的 作 用 域 Java 对 象 (Object) 与 基 本 数 据 类 型 的 作 用 域 不 同, 原 因 是 自 动 变 量 一 般 存 储 在 堆 栈 之 中, 当 程 序 走 出 该 块 (Block) 时, 块 内 的 所 有 自 动 变 量 就 自 动 消 失 了, 而 对 象 存 储 在 堆 之 中,

不 受 堆 栈 变 化 的 影 响 当 你 用 new 生 成 一 个 Object 之 后, 该 Object 将 一 直 存 在, 直 到 Java 垃 圾 回 收 器 (garbage collector) 认 为 该 Object 已 经 没 有 人 使 用 而 将 其 回 收 为 止 比 如 : { String s = new String( asdf ); 引 用 s 的 作 用 域 是 代 码 中 由 花 括 号 所 决 定 的 范 围 然 而 引 用 s 所 指 向 的 Object 却 不 因 为 反 花 括 号 的 出 现 而 自 动 消 失 当 然 在 上 述 代 码 中, 程 序 走 出 反 花 括 号 后, 该 String Object 已 经 没 有 人 再 使 用 了, 所 以 垃 圾 回 收 器 有 可 能 将 其 回 收 如 果 将 上 述 代 码 修 改 为 { String a; { String s = new String( asdf ); a = s; // 此 时 在 上 个 花 括 号 范 围 内 生 成 的 String Object 还 存 在 System.out.println( String Object 的 内 容 : + a ); 那 么, 当 引 用 s 自 动 消 失 之 后, 我 们 生 成 的 String Object 还 存 在, 还 可 以 通 过 引 用 a 来 使 用 它 4. 生 成 新 的 数 据 类 型 我 们 说 在 Java 语 言 中 任 何 事 物 都 是 Object, 那 么 是 什 么 东 西 决 定 同 一 类 Object 的 外 观 和 行 为 呢? 答 案 是 类 (class) 我 们 用 关 键 词 class 来 生 成 同 一 类 Object 的 数 据 类 型 比 如 铅 笔 我 们 可 以 用 Java 语 言 实 现 如 下 :

class Pencil { private String brand; private String hardness; public Pencil( String b, String h ) { brand = b; hardness = h; public void draw() { /* 画 法 在 这 里 实 现 */ 在 定 义 了 Pencil 这 个 新 的 数 据 类 型 之 后, 我 们 就 可 以 生 成 该 类 型 的 Object 了 : Pencil p = new Pencil( 中 华 ", HB ); 上 述 语 句 生 成 了 一 个 品 牌 为 中 华 硬 度 为 HB 的 铅 笔 数 据 成 员 与 方 法 在 面 向 对 象 程 序 开 发 过 程 中, 我 们 所 需 要 做 的 就 是 找 出 系 统 中 的 Object, 定 义 这 些 Object 的 类 型, 生 成 这 些 Object, 然 后 给 这 些 Object 发 送 消 息 一 个 Object 除 了 知 道 有 关 自 己 的 信 息 和 状 态 外, 它 还 具 有 两 类 行 为 : 它 自 己 能 够 完 成 的 行 为 和 别 人 对 它 完 成 的 行 为 上 述 信 息 和 状 态 以 类 的 数 据 成 员 的 形 式 存 在, 而 那 些 行 为 则 以 方 法 / 函 数 的 形 式 存 在 所 谓 方 法 与 C 和 C++ 语 言 中 的 函 数 一 样, 但 是 在 Java 中, 我 们 一 般 称 之 为 方 法, 意 思 是 完 成 特 定 行 为 的 方 法 当 然, 如 果 你 觉 得 方 法 叫 起 来 别 扭, 你 可 以 继 续 使 用 函 数 这 个 名 称 下 列 代 码 定 义 了 一 个 只 有 数 据 成 员 的 类 class DataOnly { int i;

float f; boolean b; 这 个 类 什 么 也 不 干, 因 此 是 个 特 别 无 聊 的 类 但 是 我 们 仍 然 可 以 生 成 该 类 的 Object: DataOnly d = new DataOnly(); 怎 样 访 问 该 Object 的 数 据 成 员 呢? 我 们 通 过 引 用. 数 据 成 员 的 形 式 访 问 对 象 的 数 据 成 员 比 如, System.out.println( d.i =, d.i ); System.out.println( d.f =, d.f ); System.out.println( d.b =, d.b ); 这 段 代 码 将 在 控 制 台 上 显 示 d.i = 0 d.f = 0.0 d.b = false 由 这 个 例 子 可 以 看 出, 当 数 据 成 员 是 基 本 数 据 类 型 时, 如 果 你 不 明 显 地 ( 显 式 地 ) 初 始 化 数 据 成 员, 那 么 这 些 数 据 成 员 将 自 动 被 初 始 化 为 缺 省 值 : 基 本 数 据 类 型 boolean false char '\u0000' byte (byte)0 short (short)0 int 0 long 0L float 0.0f double 0.0d 缺 省 值 这 个 自 动 初 始 化 过 程 只 对 数 据 成 员 有 效, 而 对 局 部 变 量 / 自 动 变 量 无 效 比 如 你 在 某 个 方 法 中 定 义 int x; 那 么, 自 动 变 量 x 将 不 会 被 自 动 初 始 化,x 的 内 容 将 是 一 个 随 机 值

方 法 形 式 参 数 返 回 值 在 C 和 C++ 语 言 中, 将 具 有 名 称 的 子 程 序 (subroutine) 称 为 函 数 (function), 而 在 Java 语 言 中 我 们 将 这 些 子 程 序 称 为 方 法 (method) 方 法 最 基 本 的 几 个 要 素 包 括 方 法 名 称, 形 式 参 数, 返 回 值 的 类 型, 方 法 主 体 : returntype methodname( /* 形 式 参 数 清 单 */ ){ /* 方 法 主 体 */ 返 回 值 类 型 是, 当 方 法 结 束 时, 回 递 给 调 用 这 个 方 法 的 其 他 方 法 的 数 据 类 型 形 式 参 数 则 决 定 了 在 调 用 该 方 法 时 传 递 给 该 方 法 的 数 据 类 型 和 名 称 我 们 利 用 方 法 名 称 和 形 式 参 数 清 单 来 唯 一 地 区 别 不 同 的 方 法 在 java 语 言 中, 方 法 只 能 作 为 类 的 一 部 分 存 在, 方 法 也 只 能 针 对 某 个 特 定 的 Object 调 用, 我 (1) 们 称 这 个 调 用 过 程 为 给 该 Object 发 送 消 息 给 object 发 送 消 息 的 格 式 如 下 : 引 用. 方 法 名 称 ( /* 要 传 递 给 方 法 的 数 据 清 单 */ ); 形 式 参 数 清 单 形 式 参 数 清 单 决 定 了 调 用 该 方 法 时 需 要 传 递 给 该 方 法 的 信 息 也 许 你 已 经 猜 到 了, 如 同 Java 中 其 他 一 切 事 物 一 样, 这 些 信 息 也 是 以 Object 的 形 式 传 递 给 方 法 的 如 我 们 前 面 讲 过 的, 传 递 的 实 际 上 是 Object 的 引 用, 而 不 是 Object 本 身 例 : int storage( String s ) { return s.length() * 2; 这 个 方 法 计 算 String 类 对 象 的 以 字 节 为 单 位 的 长 度 可 以 看 出, 当 Object 的 引 用 作 为 形 式 参 数 传 递 到 一 个 方 法 后, 这 个 引 用 跟 一 个 正 常 的 引 用 没 有 区 别, 你 同 样 可 以 给 这 个 引 用 指 向 的 Object 发 送 消 息 在 这 个 例 子 中, 通 过 给 s 指 向 的 Object 发 送 消 息 length() 来 获 取 该 Object 的 以 char 为 单 位 的 长 度 (1) 但 是 也 有 特 例, 比 如 我 们 将 要 介 绍 的 静 态 (static) 方 法 就 直 接 可 以 针 对 类 调 用

static 关 键 词 如 前 所 述, 访 问 对 象 的 数 据 成 员 或 方 法 时, 我 们 总 是 向 某 个 具 体 的 对 象 发 出 请 求 不 同 的 对 象 可 能 会 有 不 同 的 响 应, 这 是 因 为 每 个 对 象 都 具 有 各 自 的 存 储 空 间 比 如 学 生 类 具 有 一 个 姓 名 成 员, 所 以 每 个 学 生 Object 就 都 拥 有 一 个 姓 名 数 据 成 员, 它 们 的 内 容 可 能 户 不 相 同 然 而, 有 两 种 情 况, 不 能 够 通 过 普 通 数 据 成 员 实 现 : 1. 我 们 希 望 同 一 类 的 Object 共 有 某 个 数 据 不 管 生 成 了 多 少 个 该 类 的 Object, 或 者 甚 至 没 有 生 成 任 何 Object, 这 个 数 据 都 存 在, 并 且 是 唯 一 的 比 如 兰 州 交 通 大 学 毕 业 生 有 一 个 共 同 的 属 性, 他 们 的 母 校 是 兰 州 交 通 大 学 在 谈 及 这 个 事 实 时, 我 们 可 以 说 交 大 毕 业 生 的 母 校 是 交 大, 而 不 一 定 要 具 体 到 某 个 毕 业 生 2. 我 们 需 要 一 个 不 与 具 体 Object 相 联 系 的 方 法 也 就 是 说, 在 没 有 生 成 类 的 Object 的 情 况 下 我 们 也 希 望 能 够 调 用 该 方 法 比 如 Java 应 用 程 序 的 入 口 方 法 main(), 在 Java 虚 拟 机 (JVM) 调 用 这 个 方 法 时, 还 没 有 来 得 及 / 没 有 机 会 生 成 应 用 程 序 这 个 类 的 任 何 Object 怎 么 办 呢? Java 提 供 了 关 键 词 static 来 实 现 这 个 功 能 当 我 们 申 明 一 个 数 据 成 员 或 方 法 为 static 时, 意 味 着 这 个 数 据 成 员 或 方 法 不 与 该 类 的 任 何 具 体 的 Object 相 联 系 所 以, 哪 怕 从 来 没 有 生 成 该 类 的 任 何 Object, 我 们 仍 然 能 够 访 问 / 使 用 该 数 据 成 员 或 方 法 而 一 般 的 非 static 数 据 成 员 或 方 法, 只 有 在 生 成 了 一 个 Object 之 后, 我 们 才 能 通 过 该 Object 去 访 问 该 数 据 成 员 或 方 法 由 此,static 方 法 就 不 能 够 直 接 访 问 该 类 的 非 static 数 据 成 员, 原 因 是 这 些 数 据 成 员 有 可 能 还 不 存 在 例 : class StaticTest { static int i = 47; static void incr() { i++; 一 旦 定 义 了 该 类, 数 据 成 员 StaticTest.i 就 存 在 了, 无 论 你 有 没 有 生 成 该 类 的 Object 或 无 论 你

生 成 了 多 少 个 该 类 的 Object, 数 据 成 员 StaticTest.i 只 有 一 个 版 本 StaticTest s1 = new StaticTest(); StaticTest s2 = new StaticTest(); 这 时,s1.i 和 s2.i 是 同 一 个 变 量, 拥 有 同 样 的 数 据 内 容 (47), 存 储 在 同 一 个 存 储 空 间 如 果 执 行 StaticTest.i = 96; 那 么, 此 时 s1.i 和 s2.i 均 改 变 为 96 静 态 方 法 StaticTest.incr() 修 改 了 静 态 变 量 StaticTest.i 的 值 ( 加 一 ) 5. 注 释 与 嵌 入 式 文 档 Java 语 言 中 有 两 类 注 释 第 一 类 是 继 承 自 C 语 言 的 注 释, 成 为 C 式 注 释, 以 /* 开 始, 以 */ 结 束, 可 以 跨 越 多 行 比 如 : /* This is a comment that continues across lines. */ 因 为 在 /* 和 */ 之 见 的 一 切 内 容 均 被 编 译 器 忽 视, 所 以, 上 述 注 释 与 下 列 注 释 相 同 /* This is a comment that continues across lines */ 第 二 种 注 释 继 承 自 C++ 语 言, 是 一 种 单 行 注 释, 以 // 开 始, 直 到 该 行 的 结 束 比 如 // This is a one-line comment 注 释 文 档 在 软 件 系 统 的 开 发 过 程 中, 编 码 非 常 重 要, 因 为 编 码 就 是 产 品, 但 是 文 档 (documentation) 管 理 同 样 重 要 好 的 文 档 可 以 提 高 软 件 的 复 用 效 果, 更 加 便 于 维 护 软 件 在 文 档 维 护 方 面, 常 见 的 问 题 编 码 和 文 档 相 互 脱 离, 不 能 保 持 相 同 的 内 容 如 果 文 档 和 编 码 是 分 开 管 理 的, 每 当 修 改 了 编 码 时, 我 们 就 必 须 记 得 去 打 开 文 档 文 件, 修 改 其 说 明 而 一 般

编 程 人 员 往 往 懒 得 去 做, 导 致 最 后 编 码 写 完 了, 可 是 没 有 像 样 的 文 档 Java 利 用 非 常 简 单 的 方 式 提 供 了 解 决 办 法 : 将 编 码 和 说 明 文 档 放 在 同 一 文 件 内 为 了 实 现 这 一 目 的, 我 们 需 要 特 殊 的 语 法 来 管 理 说 明 文 档, 并 需 要 特 殊 的 软 件 提 取 说 明 文 档 Java 用 Javadoc 应 用 软 件 提 取 文 件 中 的 说 明 文 档 Javadoc 的 输 出 结 果 是 HTML 文 件, 可 以 利 用 Web 浏 览 器 阅 读 注 释 文 档 的 语 法 Javadoc 命 令 以 /** 开 始, 以 */ 结 束 在 javadoc 命 令 中 可 以 插 入 HTML, 也 可 以 使 用 文 档 标 签 (doc tags) 文 档 标 签 分 为 两 类 一 类 是 独 立 标 签 (standalone tags), 另 外 一 类 是 内 嵌 式 标 签 (inline tags) 独 立 标 签 以 @ 开 始, 置 于 一 行 的 开 始 ( 它 之 前 的 空 格 和 * 被 忽 略 ), 单 独 占 据 一 行 内 嵌 式 标 签 也 以 @ 开 始, 但 是 整 个 标 签 用 花 括 号 围 起 来 注 释 文 档 分 别 出 现 在 类 变 量 方 法 的 前 方, 分 别 注 释 对 应 的 类 变 量 方 法 也 就 是 说, 类 的 说 明 文 档 以 Javadoc 命 令 的 形 式 出 现 在 该 类 的 前 方 ; 变 量 ( 数 据 成 员 ) 的 说 明 文 档 出 现 在 该 变 量 的 前 方 ; 方 法 的 说 明 文 档 出 现 在 该 方 法 之 前 比 如 /** 关 于 类 DocTest 的 说 明 文 档 */ public class DocTest { /** 关 于 数 据 成 员 i 的 说 明 文 档 */ public int i; /** 关 于 方 法 f() 的 说 明 文 档 */ public void f() { /* 方 法 主 体 */ Javadoc 只 处 理 public 和 protected 成 员 的 注 释 文 档, 而 忽 略 private 和 default-access ( 缺 省 访 问 控 制 ) 成 员 的 注 释 文 档 这 是 因 为 别 人 只 能 使 用 public 和 protected 成 员 当 然 如 果 需 要, 你 可 以 通 过 在 命 令 行 加 上 -private 来 迫 使 Javadoc 也 处 理 private 成 员 的 注 释 文 档

嵌 入 HTML Javadoc 直 接 将 HTML 命 令 复 制 到 结 果 文 件 中 去, 这 样 你 就 可 以 利 用 HTML 命 令 控 制 文 档 的 格 式 比 如 : /** */ 你 甚 至 <em> 可 以 强 调 某 些 文 字 </em>, 也 可 以 插 入 清 单 <ol> <li> 这 是 第 一 项 <li> 这 是 第 二 项 </ol> 但 是, 注 意 不 要 使 用 诸 如 <h1>,<hr> 这 样 的 标 题 控 制 符, 因 为 Javadoc 根 据 需 要 自 己 控 制 着 标 题, 你 的 标 题 控 制 符 会 干 扰 它 的 标 题 常 见 的 标 签 标 签 说 明 引 用 别 的 类 的 说 明 文 档 Javadoc 会 在 接 过 文 件 中 产 生 一 个 see @see also 标 签 通 过 超 联 连 接 到 指 定 类 或 方 法 的 说 明 文 档 的 超 链 用 法 : {@link 包. 类 # 成 员 @see 类 名 @see 类 名 # 方 法 名 与 @see 相 近, 不 同 在 于 可 用 于 在 一 个 行 内 生 成 指 向 某 个 类 或 方 法 的 超 联 {@docroot 产 生 到 文 档 根 目 录 的 相 对 路 径 {@inheritdoc 从 最 近 的 父 类 继 承 文 档 @version 版 本 号 码 用 于 指 定 程 序 的 版 本 @author 作 者 信 息 用 于 指 定 程 序 的 作 者 信 息, 可 以 包 括 作 者 名 称 作 者 的 电 子 邮 件 地 址 等 任 何 有 关 作 者 的 信 息 可 以 指 定 多 个 @author 标 签, 但 是 他 们 必 须 是 连 续 的, 彼 此 之 间 不 能 插 入 别 的 标 签 @since 必 要 的 信 息 用 于 指 定 程 序 适 应 的 JDK 版 本 @param 变 量 名 称 说 明 用 于 方 法 说 明 文 档, 说 明 方 法 的 参 数 名 称, 以 及 使 用 反 方 法 @return 说 明 用 于 方 法 说 明 文 档, 所 名 方 法 的 返 回 值

标 签 说 明 @throws 例 外 类 型 说 明 用 于 方 法 说 明 文 档, 所 名 方 法 可 能 产 生 的 异 常 @deprecated 用 来 说 明 某 个 功 能 已 经 过 时, 已 经 被 其 他 功 能 替 代 注 释 文 档 举 例 下 面 的 例 子 中, 我 们 定 义 了 一 个 Student 类 我 们 在 定 义 该 类 的 同 时, 我 们 为 类 数 据 成 员 方 法 都 用 注 释 文 档 的 方 式 书 写 了 说 明 /** * 类 Student 代 表 学 生 同 时 Student 类 又 可 以 作 为 应 用 程 序 使 用, * 因 为 它 定 义 了 main() 方 法 作 为 应 用 程 序 时, 它 完 成 的 功 能 清 参 * 见 {@link #main(string[]) * * @since JDK1.0 该 程 序 在 JDK1.0 以 上 环 境 中 运 行 * @version 1.0 * @author jihsian lee * @author jihsianlee@mail.lzjtu.cn */ public class Student { /** * name 代 表 学 生 的 姓 名 */ private String name; /** * 类 Student 的 构 造 方 法 * @param s 生 成 Student 对 象 时, 传 递 的 姓 名 */ public Student(String s){ name = s; /** * 学 生 唱 歌 的 方 法 该 方 法 将 在 控 制 台 上 显 示 某 某 学 生 正 在 唱 歌 */ public void singing(){ System.out.println(" 学 生 " + name + " 在 唱 歌..." ); /** * 学 生 跳 舞 的 方 法 该 方 法 将 在 控 制 台 上 显 示 某 某 学 生 正 在 跳 舞 * */ public void dancing(){ System.out.println(" 学 生 " + name + " 在 跳 舞...");

/** * main() 方 法 是 应 用 程 序 的 入 口 我 们 希 望 Student 类 可 作 为 应 用 程 序 运 行, * 所 以 我 们 必 须 定 义 该 方 法 这 个 应 用 程 序 完 成 如 下 工 作 : * <ol> * <li> 首 先 生 成 一 个 Student 类 的 对 象 ; * <li> 然 后 向 该 学 生 发 出 请 求, 要 求 她 唱 歌 ; 有 关 学 生 唱 歌 的 方 法, * 请 参 见 {@link #singing() * <li> 最 后 向 该 学 生 发 出 请 求, 要 求 她 跳 舞 有 关 学 生 跳 舞 的 方 法, * 请 参 见 {@link #dancing() * </ol> * @param args 命 令 行 参 数 在 该 程 序 中 我 们 忽 略 命 令 行 参 数 */ public static void main(string[] args){ Student s = new Student("Cathy"); s.singing(); s.dancing(); 在 编 写 完 该 代 码 之 后, 我 们 可 以 通 过 命 令 行 指 令 javadoc Student.java 该 命 令 在 当 前 文 件 加 生 成 有 关 Student 类 的 使 用 说 明 6. Java 编 程 格 式 Java 语 言 的 标 识 符 由 除 了 代 表 运 算 符 号, 豆 号 句 号 引 号 等 特 殊 字 符 以 外 的 符 号 组 成 但 是 标 识 符 首 字 不 能 以 数 字 (0-9) 开 始 标 识 符 区 分 大 小 写 关 于 编 程 格 式, 请 参 考 http://java.sun.com/docs/codeconv/index.html 总 的 来 说, 建 议 类 名 的 第 一 个 字 母 大 写, 同 一 单 词 中 其 余 字 母 小 写 如 果 类 名 由 多 个 单 词 组 成, 那 么 每 个 单 词 的 首 字 大 写, 单 词 之 间 紧 接 如 class AllTheColorsOfTheRainbow { //... 方 法 名 数 据 成 员 名 变 量 名 对 象 引 用 名 等, 建 议 使 用 小 写 字 母 如 果 名 称 由 多 个 单 词 组 成, 则 除 第 一 个 但 此 外 其 余 单 词 的 首 字 大 写, 单 词 之 间 紧 接 如 int anintegerrepresentingcolos;

void changethehueofthecolor( int newhue ){ //... 7. Eclipse Eclipse 是 Java 语 言 众 多 集 成 开 发 环 境 中 的 一 个, 由 于 它 是 共 享 软 件, 并 且 由 于 它 的 强 大 的 功 能, 受 到 很 多 人 的 欢 迎 本 书 中 的 Java 程 序 都 是 在 Eclipse 环 境 中 开 发 调 适 的 Eclipse 通 过 工 作 空 间 ( workspace ) 来 管 理 代 码 每 个 工 作 空 间 内 可 包 含 多 个 项 目 (Project), 每 个 项 目 当 然 可 以 包 含 多 个 类 有 关 利 用 Eclipse 开 发 程 序 的 方 法, 我 们 将 在 后 续 章 节 中 逐 步 讲 解 在 此, 我 们 将 首 先 介 绍 利 用 Eclipse 开 发 HelloJava 类 的 过 程 : 1. 启 动 Eclipse 2. 制 定 工 作 空 间 原 则 上, 一 个 工 作 空 间 由 一 个 编 程 人 员 所 有, 而 一 个 编 程 人 员 可 拥 有 多 个 工 作 空 间 我 将 我 的 工 作 空 间 存 储 在 我 的 计 算 机 系 统 的 F 盘 的 LeeDev 文 件 夹 内, 所 以, 我 的 工 作 空 间 选 择 为 F:\LeeDev 3. 点 击 菜 单 项 Window, 然 后 选 择 Open Perspective Java 告 诉 Eclipse 我 们 开 发 的 是 Java 程 序 Eclipse 是 个 通 用 集 成 开 发 环 境, 既 可 以 开 发 Java 程 序, 也 可 以 开 发 别 的 语 言 的 程 序 4. 在 该 工 作 空 间 内 生 成 一 个 项 目 完 转 Object 本 书 中, 我 们 将 每 章 作 为 一 个 项 目,

项 目 的 名 称 与 每 章 的 名 称 相 同 为 了 生 成 项 目 完 转 Object, 点 击 菜 单 项 File new Project 5. 在 随 后 出 现 的 New Java Project 对 话 框 中,Project name: 栏 输 入 完 转 Object 6. 按 下 Finish 按 钮

7. 选 择 Package Explorer 中 的 完 转 Object 项 目, 选 择 菜 单 项 File new class, 然 后 再 弹 出 的 New Java Class 对 话 框 的 name: 栏 输 入 HelloJava 8. 按 下 该 对 话 框 的 Finish 按 钮

9. Eclipse 中 间 区 域 就 会 出 现 HelloJava.java 的 编 辑 窗 口, 其 中 Eclipse 已 经 自 动 为 我 们 写 出 了 类 HelloJava 的 定 义 10. 在 main() 方 法 中 增 加 System.out.println( Hello, Java! ); 11. 按 下 File Save 保 存 Eclipse 在 保 存 文 件 的 同 时, 就 自 动 完 成 了 编 译 工 作 12. 作 为 应 用 程 序 运 行 该 程 序 操 作 顺 序 : Run Run as Java Application

13. 运 行 结 果 显 示 在 Eclipse 的 Console 面 板 :