尽 管 Java 语 言 是 在 C++ 语 言 基 础 上 发 展 起 来 的, 但 是 有 别 于 C++,Java 是 一 种 纯 粹 的 面 向 对 象 语 言 (Object-oriented language) 在 像 Java 这 样 纯 粹 的 面 向 对 象 语 言 中, 所 有

玩 转 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 3-1/13

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

化 而 对 于 一 般 的 情 况, 我 们 必 须 使 用 通 用 的 初 始 化 过 程 2. 必 须 创 建 (create) 所 有 的 Object 如 何 创 建 一 个 Object? 我 们 一 般 使 用 关 键 词 new new 意 味 着 为 我 生 成 这 类 对 象 的 一 个 新 的 实 体 所 以, 上 述 例 子 中 生 成 一 个 字 符 串 的 更 加 通 用 的 做 法 是 String s = new String( asdf ); 这 句 话 的 意 思 是 : 请 利 用 字 符 串 常 量 asdf 为 我 生 成 一 个 字 符 串 对 象 (Object) Java 标 准 库 提 供 了 大 量 的 类, 同 时 你 也 可 以 编 写 自 己 的 类 实 际 上, 编 写 类 是 用 Java 语 言 开 发 程 序 的 最 主 要 的 工 作, 也 是 我 们 课 程 讲 述 的 主 要 内 容 计 算 机 存 储 系 统 当 计 算 机 程 序 运 行 时, 有 六 种 不 同 的 地 方 可 以 存 储 信 息 : 1. 寄 存 器 (Register) 2. 堆 栈 (Stack) 3. 堆 (Heap) 4. 静 态 存 储 (Static Storage) 5. 常 量 存 储 (Constant Storage) 6. 非 内 存 存 储 (Non-RAM Storage) Java 的 Object 通 过 new 生 成, 全 部 存 储 在 堆 中 特 例 : 基 本 数 据 类 型 (primitive types) Java 的 基 本 数 据 类 型 boolean, char, byte, short, int, long, float, double 的 数 据 没 有 必 要 通 过 new 3-3/13

生 成 这 些 数 据 存 储 在 堆 栈 中 ( 考 虑 到 速 度 ) Primitive type Size Minimum Maximum Wrapper type 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++ 语 言 中, 因 为 需 要 编 程 人 员 负 责 将 变 量 所 占 据 的 内 存 归 还 给 系 统, 变 量 的 销 毁 问 题 变 成 了 编 程 人 员 的 一 大 负 担 经 常 会 因 为 编 程 人 员 忘 记 了 销 毁 变 量 而 导 致 系 统 内 存 枯 竭, 系 统 瘫 痪 变 量 的 作 用 域 (Scoping) 如 同 C 和 C++ 语 言 一 样,Java 语 言 中 变 量 的 作 用 域 由 花 括 号 控 制 比 如 int x = 12; // 只 有 变 量 x 可 用 int q = 96; // 此 时 变 量 x 和 q 均 可 使 用 // 只 有 变 量 x 可 用, 此 时 已 经 超 出 变 量 q 的 作 用 域 如 上 述 例 子 所 示, 在 一 个 范 围 / 作 用 域 内 定 义 的 变 量 只 在 那 个 作 用 域 内 存 在 3-4/13

int x = 12; int x = 96; // 语 法 错 误! 上 述 代 码 在 C 和 C++ 中 是 合 法 的, 但 是 在 Java 中 是 语 法 错 误 Object 的 作 用 域 Java 对 象 (Object) 与 基 本 数 据 类 型 的 作 用 域 不 同 当 你 用 new 生 成 一 个 Object 之 后, 该 Object 将 一 直 存 在, 直 到 Java 垃 圾 回 收 器 (garbage collector) 认 为 该 Object 已 经 没 有 人 使 用 而 将 其 回 收 为 止 比 如 : String s = new String( asdf ); 中, 引 用 s 的 作 用 域 是 代 码 中 由 花 括 号 所 决 定 的 范 围 然 而 引 用 s 所 指 向 的 Object 却 不 因 为 反 花 括 号 的 出 现 而 自 动 消 失 当 然 在 上 述 代 码 中, 显 然 该 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 的 外 观 和 行 为? 3-5/13

我 们 用 关 键 词 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 中, 我 们 一 般 称 之 为 方 法, 意 思 是 完 成 特 定 行 为 的 方 法 当 然, 如 果 你 觉 得 方 法 叫 起 来 别 扭, 你 可 以 继 续 使 用 函 数 这 个 名 称 3-6/13

下 列 代 码 定 义 了 一 个 只 具 有 数 据 成 员 的 类 class DataOnly int i; float f; boolean b; 这 个 类 什 么 也 不 干, 因 此 是 个 特 别 无 聊 的 类 但 是 我 们 仍 然 可 以 生 成 该 类 的 Object: DataOnly d = new DataOnly(); 怎 样 访 问 该 Object 的 数 据 成 员 呢? ObjectReferenceName.member 比 如, 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 缺 省 值 这 个 自 动 初 始 化 过 程 只 对 数 据 成 员 有 效, 而 对 局 部 变 量 / 自 动 变 量 无 效 比 如 你 在 某 个 方 法 中 定 义 3-7/13

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

Object 发 送 消 息 在 这 个 例 子 中, 通 过 给 s 指 向 的 Object 发 送 消 息 length 来 获 取 该 Object 的 以 char 为 单 位 的 长 度 static 关 键 词 一 般 来 讲, 当 你 创 建 一 个 类 时, 你 在 描 述 这 个 类 的 Object 的 外 观 和 行 为 仅 仅 创 建 这 个 类, 你 并 没 有 得 到 任 何 实 际 的 东 西, 直 到 你 用 new 创 建 一 个 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++; 3-9/13

一 旦 定 义 了 该 类, 数 据 成 员 StaticTest.i 就 存 在 了, 无 论 你 有 无 生 成 该 类 的 Object 或 无 论 你 生 成 了 多 少 个 该 类 的 Object, 数 据 成 员 StaticTest.i 只 有 一 个 版 本, 方 法 StaticTest.incr() 也 就 可 以 调 用 了 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) 管 理 同 样 重 要 好 的 文 档 可 以 提 高 软 件 的 复 用 效 果, 更 加 便 于 维 护 软 件 3-10/13

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

要, 你 可 以 通 过 在 命 令 行 加 上 -private 来 迫 使 Javadoc 也 处 理 private 成 员 的 注 释 文 档 嵌 入 HTML Javadoc 直 接 将 HTML 命 令 复 制 到 结 果 文 件 中 去, 这 样 你 就 可 以 利 用 HTML 命 令 控 制 文 档 的 格 式 比 如 : /** */ 你 甚 至 <em> 可 以 强 调 某 些 文 字 </em>, 也 可 以 插 入 清 单 <ol> <li> 这 是 第 一 项 <li> 这 是 第 二 项 <li>item number three </ol> 但 是, 注 意 不 要 使 用 诸 如 <h1>,<hr> 这 样 的 标 题 控 制 符, 因 为 Javadoc 根 据 需 要 自 己 控 制 着 标 题, 你 的 标 题 控 制 符 会 干 扰 它 的 标 题 常 见 的 标 签 @see... 引 用 别 的 类 的 说 明 文 档 Javadoc 会 在 接 过 文 件 中 产 生 一 个 连 接 到 指 定 类 或 方 法 的 说 明 文 档 的 超 链 用 法 : @see 类 名 @see 类 名 # 方 法 名 @link 包. 类 # 成 员 标 志 @docroot @inheritdoc @version 版 本 号 码 @author 作 者 信 息 @since 必 要 的 信 息 3-12/13

@param 变 量 名 称 说 明 @return 说 明 @throws 例 外 类 型 说 明 @deprecated 6. Java 编 程 格 式 Java 语 言 的 标 识 符 由 字 母 (A-Z, a-z),_,$, 和 (0-9) 组 成, 共 计 64 个 可 选 字 符 但 是 标 识 符 首 字 不 能 以 数 字 (0-9) 开 始 标 识 符 区 分 大 小 写 关 于 编 程 格 式, 请 参 考 http://java.sun.com/docs/codeconv/index.html 总 的 来 说, 建 议 类 名 的 第 一 个 字 母 大 写, 同 一 单 词 中 其 余 字 母 小 写 如 果 类 名 由 多 个 单 词 组 成, 那 么 每 个 单 词 的 首 字 大 写, 单 词 之 间 紧 接 如 class AllTheColorsOfTheRainbow //... 对 于 别 的 除 了 类 名 以 外 的 方 法 名 数 据 成 员 名 变 量 名 对 象 引 用 名 等, 建 议 使 用 小 写 字 母 如 果 名 称 由 多 个 单 词 组 成, 则 其 余 单 词 的 首 字 大 写, 单 词 之 间 紧 接 如 int anintegerrepresentingcolos; void changethehueofthecolor( int newhue ) //... 3-13/13