Microsoft Word Java面向对象程序设计（第二版）新正文.doc

Transcription

1 第 3 章 类 与 对 象 类 和 对 象 的 概 念 类 的 编 写 方 法 和 对 象 的 创 建 类 的 成 员 变 量 的 定 义 类 的 成 员 方 法 的 定 义 包 的 概 念 访 问 权 限 内 部 类 及 泛 型 类 理 解 类 和 对 象 的 基 本 概 念 掌 握 类 和 对 象 的 创 建 与 应 用 理 解 方 法 和 构 造 方 法 的 概 念 掌 握 方 法 的 声 明 和 调 用 理 解 包 的 概 念 掌 握 类 及 其 成 员 访 问 权 限 控 制 理 解 内 部 类 的 基 本 概 念 编 写 简 单 的 面 向 对 象 程 序 3.1 引 例 例 3.1 用 面 向 对 象 的 思 想 来 设 计 一 个 简 单 的 程 序, 求 一 个 矩 形 的 周 长 和 面 积 分 析 : 以 面 向 对 象 的 程 序 设 计 方 式 来 思 考 这 一 问 题, 我 们 可 以 通 过 以 下 几 步 来 解 决 : (1) 用 一 个 合 适 的 名 字 ( 如 Rectangle) 来 标 识 我 们 要 分 析 的 客 观 实 体 ( 矩 形 ) (2) 分 析 客 观 实 体 的 共 有 特 征 : 长 和 宽, 用 length 和 width 两 个 属 性 对 其 进 行 描 述 (3) 分 析 客 观 实 体 的 共 有 功 能, 用 perimeter() 和 area() 两 个 方 法 来 实 现 其 功 能 (4) 设 计 矩 形 类 和 一 个 测 试 类 (5) 在 测 试 类 中, 用 矩 形 类 产 生 一 个 矩 形 对 象, 并 计 算 其 周 长 和 面 积 程 序 代 码 如 下 : // 文 件 名 Jpro3_1.java class Rectangle // 定 义 类

2 38 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) float length; // 定 义 属 性 float width; // 定 义 属 性 double perimeter() // 定 义 方 法 return 2*(length+width); double area() // 定 义 方 法 return length*width; public class Jpro3_1 // 定 义 类 // 定 义 程 序 执 行 的 入 口 方 法 Rectangle r1=new Rectangle(); // 创 建 对 象 r1.length=5.5f; // 给 对 象 的 属 性 赋 值 r1.width=3.5f; double zc= r1.perimeter(); // 调 用 perimeter() 方 法 计 算 周 长 System.out.println(" 矩 形 的 周 长 是 :"+zc); // 输 出 周 长 System.out.println(" 矩 形 的 面 积 是 :"+r1.area()); // 计 算 并 输 出 面 积 程 序 运 行 结 果 : 矩 形 的 周 长 是 :18.0 矩 形 的 面 积 是 :19.25 程 序 分 析 : 在 上 述 Java 源 程 序 Jpro3_1.java 中, 定 义 了 两 个 类 第 一 个 类 为 矩 形 类, 类 名 为 Rectangle, 用 于 实 现 对 矩 形 实 体 的 共 同 的 属 性 和 方 法 的 封 装 ; 第 二 个 类 的 类 名 Jpro3_1 与 源 程 序 名 相 同, 该 类 的 主 要 功 能 不 是 用 来 封 装 实 体, 而 是 用 于 编 写 算 法 对 前 面 的 Rectangle 类 的 功 能 进 行 测 试, 因 此, 不 妨 称 其 为 测 试 类 在 测 试 类 中 首 先 定 义 了 一 个 程 序 执 行 的 入 口 方 法 main(), 在 该 方 法 中 用 矩 形 类 定 义 矩 形 对 象, 再 利 用 矩 形 对 象 调 用 其 相 应 的 属 性 和 方 法 完 成 其 相 应 的 功 能 为 了 解 决 这 个 问 题, 在 开 始 的 分 析 中, 我 们 提 到 了 几 个 概 念 : 类 属 性 对 象 和 方 法, 它 们 究 竟 有 什 么 意 义, 下 面 将 一 一 介 绍 3.2 类 将 客 观 世 界 中 的 一 个 特 定 种 类 的 实 体 放 在 一 起, 并 抽 取 它 们 身 上 共 性 加 以 描 述, 这 就 得 到 了 软 件 系 统 中 的 类 因 此, 通 常 从 下 面 三 个 方 面 来 描 述 一 个 类 : 1 有 一 个 名 字 来 唯 一 标 识 它 所 描 述 的 客 观 实 体 2 有 一 组 属 性 来 描 述 客 观 实 体 的 共 有 特 征 3 有 一 组 方 法 来 实 现 客 观 实 体 的 共 有 行 为 类 是 组 成 Java 程 序 的 基 本 要 素 类 封 装 了 一 类 对 象 的 属 性 和 方 法 类 是 用 来 定 义 对 象 的 模 板, 当 使 用 一 个 类 创 建 了 一 个 对 象 时, 我 们 也 说 给 出 了 这 个 类 的 一 个 实 例

3 3.2.1 类 的 声 明 Java 语 句 中 类 的 定 义 通 常 包 含 两 个 部 分 : 类 声 明 和 类 体 其 基 本 格 式 如 下 : class 类 名 类 体 的 内 容 其 中, class 类 名 是 类 的 声 明 部 分 class 是 关 键 字, 用 来 定 义 类 类 名 指 的 是 类 的 名 称, 类 名 的 命 名 与 标 识 符 的 命 名 一 致 类 名 的 命 名 规 则 是, 类 名 的 第 一 个 字 母 通 常 要 大 写, 如 果 类 名 是 多 个 单 词 连 接 而 成, 每 个 单 词 首 字 母 都 大 写, 如 BeijingChangcheng HelloChina ComputerArea 等 类 名 最 好 能 体 现 类 的 功 能 或 作 用 当 定 义 一 个 类 时, 我 们 可 以 在 class 类 名 前 加 public abstract 和 final 等 修 饰 符 对 所 定 义 类 的 特 征 进 行 限 制 还 可 以 在 其 后 加 extends < 父 类 名 > 和 implements < 接 口 名 列 表 > 来 说 明 类 的 继 承 性 这 些 内 容 在 后 面 的 章 节 中 将 会 陆 续 介 绍 类 体 的 构 成 定 义 类 的 目 的 是 为 了 描 述 一 类 事 物 共 有 的 属 性 和 功 能, 即 将 数 据 和 对 数 据 的 操 作 封 装 在 一 起, 这 一 过 程 由 类 体 来 实 现 类 体 通 常 有 两 种 类 型 的 成 员 : 1 成 员 变 量 通 过 变 量 声 明 定 义, 来 描 述 类 创 建 的 对 象 的 属 性 2 成 员 方 法 通 过 方 法 的 声 明 定 义, 来 描 述 类 创 建 的 对 象 的 功 能 封 装 的 思 想 就 是 将 数 据 和 对 数 据 的 操 作 封 装 在 一 起, 当 一 个 对 象 执 行 自 己 的 操 作 时, 它 对 外 界 隐 藏 了 操 作 的 细 节 如 当 人 们 看 电 视 时, 通 常 大 部 分 人 都 不 关 心 电 视 机 机 壳 里 隐 藏 的 复 杂 电 子 元 器 件, 也 不 关 心 这 些 电 子 器 件 是 如 何 工 作 来 产 生 电 视 画 面 的 电 视 机 做 了 自 己 要 做 的 事 并 对 我 们 隐 藏 了 它 的 工 作 过 程 如 何 才 能 做 到 对 类 的 合 理 封 装 呢? 这 要 通 过 合 理 地 定 义 类 中 的 成 员 变 量 和 成 员 方 法 来 实 现 1. 成 员 变 量 的 定 义 定 义 成 员 变 量 最 简 单 的 格 式 为 : 类 型 变 量 名 1[, 变 量 名 2, ] 如 果 我 们 把 变 量 名 前 的 所 有 关 键 字 称 为 该 变 量 的 修 饰 符, 那 么 变 量 的 类 型 修 饰 符 是 必 须 有 的 它 决 定 该 变 量 在 内 存 中 分 配 空 间 的 大 小 成 员 变 量 可 以 是 简 单 类 型, 如 byte int long boolean float double; 也 可 以 是 数 组 字 符 串 或 类 等 引 用 类 型 每 个 类 中 的 成 员 变 量 类 型 的 定 义, 要 根 据 具 体 情 况 来 定, 不 能 一 概 而 论 如 将 例 3.1 中 Rectangle 类 中 的 length 和 width 定 义 为 int 型 是 否 可 以? class Rectangle int length; int width; 这 样 的 定 义 对 于 程 序 来 说 完 全 可 以, 只 不 过 在 现 实 世 界 中, 矩 形 的 长 和 宽 并 非 总 是 整 数, 第 3 章 类 与 对 象 39

4 40 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 所 以 定 义 为 float 类 型 比 int 类 型 更 具 有 实 际 意 义 那 么, 例 3.1 中 关 于 矩 形 长 和 宽 的 定 义 是 否 合 理 呢? class Rectangle float length; float width; 从 类 的 封 装 性 来 看, 上 面 的 定 义 并 不 理 想 由 于 Rectangle 类 中 的 成 员 变 量 的 访 问 权 限 修 饰 符 为 缺 省 情 况, 于 是 在 测 试 类 Jpro3_1 中, 我 们 可 以 对 Rectangle 类 的 成 员 变 量 直 接 进 行 操 作 pubic class Jpro3_1 Rectangle r1=new Rectangle(); r1.length=5.5f; r1.width=3.5f; 这 就 相 当 于 一 个 电 视 机 除 去 了 机 壳, 任 何 人 都 可 能 对 其 里 面 的 器 件 直 接 进 行 操 作, 没 了 任 何 封 装 性, 其 安 全 性 就 受 到 了 威 胁 对 于 软 件 系 统 来 说, 封 装 有 什 么 作 用 呢? 在 一 个 包 含 许 多 对 象 的 系 统 中, 对 象 之 间 以 各 种 方 式 相 互 依 赖 如 果 其 中 一 个 对 象 出 现 了 故 障, 软 件 工 程 师 不 得 不 修 改 它 的 时 候, 对 其 他 的 对 象 隐 藏 这 个 对 象 的 操 作 意 味 着 只 需 修 改 这 个 对 象 而 不 需 改 变 其 他 对 象 如 上 面 的 Rectangle 类 的 定 义 中, 如 果 将 成 员 变 量 length 的 类 型 由 float 改 为 int, 那 么 测 试 类 Jpro3_1 中 的 语 句 r1.length=5.5f;, 将 不 能 通 过 编 译 要 解 决 上 述 问 题, 我 们 可 以 在 定 义 成 员 变 量 时 再 加 上 访 问 权 限 修 饰 符, 其 格 式 如 下 : [ 访 问 权 限 ] 类 型 变 量 名 1[, 变 量 名 2, ] 成 员 变 量 常 用 的 访 问 权 限 修 饰 符 有 4 种 :public( 公 共 的 ) protected( 受 保 护 的 ) private ( 私 有 的 ) 和 default( 缺 省 的 ) Rectangle 类 中 的 成 员 变 量 没 有 使 用 访 问 权 限 修 饰 符, 也 就 是 访 问 权 限 修 饰 符 缺 省, 此 时, 同 一 个 包 ( 具 体 见 节 ) 中 的 其 他 类 就 能 对 其 进 行 访 问 要 实 现 类 的 成 员 变 量 在 类 的 外 部 不 可 见, 就 必 须 使 用 private 修 饰 符 对 其 进 行 限 定 用 private 修 饰 的 成 员 变 量 只 在 本 类 中 有 效, 因 此, 可 以 实 现 数 据 最 严 密 的 封 装 如 可 将 例 3.1 中 关 于 矩 形 长 和 宽 的 定 义 修 改 成 如 下 形 式 : class Rectangle private float length; private float width; 这 样, 外 部 类 就 不 能 直 接 访 问 其 成 员 变 量 了 如 将 Rectangle 类 的 两 个 成 员 变 量 定 义 为 私 有, 那 么 测 试 类 Jpro3_1 中 两 条 访 问 成 员 变 量 的 语 句 将 无 效 如 : public class Jpro3_1 Rectangle r1=new Rectangle();

5 r1.length=5.5f; r1.width=3.5f; // 非 法 // 非 法 接 下 来 的 问 题 是 : 如 果 外 部 类 无 法 访 问 其 他 类 私 有 的 成 员 变 量, 那 么, 每 个 类 私 有 的 成 员 变 量 又 该 如 何 赋 值 呢? 我 们 有 三 种 途 径 来 解 决 这 个 问 题 : 1 在 定 义 成 员 变 量 时 赋 初 值 2 在 类 中 定 义 成 员 方 法 时 给 成 员 变 量 赋 值 3 利 用 构 造 方 法 给 成 员 变 量 赋 初 值 2. 成 员 变 量 的 初 始 化 成 员 变 量 定 义 时 如 果 没 有 赋 值, 则 其 初 值 是 它 的 默 认 值 例 如,byte short int 和 long 类 型 的 默 认 值 为 0,float 类 型 的 默 认 值 为 0.0f,double 类 型 默 认 值 为 0.0,boolean 类 型 的 默 认 值 为 false,char 类 型 默 认 值 为 \u0000, 引 用 类 型 默 认 值 为 null 但 有 时 我 们 需 要 变 量 具 有 其 他 初 值, 那 么 可 以 在 定 义 的 同 时 给 变 量 赋 值 如 在 定 义 Rectangle 类 的 成 员 变 量 时, 直 接 给 长 和 宽 赋 初 值 : class Rectangle private float length=5.5f; private float width=3.5f; 注 意 以 下 的 写 法 是 错 误 的 : class Rectangle private float length; length=5.5f; // 非 法 上 述 程 序 中 的 错 误 反 映 了 这 样 一 个 问 题 : 对 成 员 变 量 的 操 作 应 放 在 方 法 中 进 行, 当 程 序 执 行 过 程 中 要 改 变 成 员 变 量 的 值, 应 设 计 相 应 的 方 法, 在 方 法 体 内 通 过 相 应 的 语 句 来 修 改 成 员 变 量 的 值 3. 成 员 方 法 在 Java 中, 方 法 只 能 作 为 类 的 成 员, 也 称 为 成 员 方 法 方 法 操 作 类 所 定 义 的 数 据, 以 及 提 供 对 数 据 的 访 问 的 代 码 大 多 数 情 况 下, 程 序 都 是 通 过 类 的 方 法 与 其 他 类 的 实 例 进 行 交 互 的 方 法 包 括 方 法 声 明 和 方 法 体 创 建 成 员 方 法 最 简 单 的 格 式 为 : 返 回 值 类 型 方 法 名 ([ 参 数 列 表 ]) 方 法 体 第 一 行 为 方 法 声 明, 大 括 号 中 的 是 方 法 体 方 法 体 可 以 包 含 一 个 或 多 个 语 句, 每 个 方 法 执 行 一 项 任 务 每 个 方 法 只 有 一 个 名 称, 通 过 使 用 这 个 名 称 方 法 才 能 被 调 用 方 法 名 一 般 用 小 写 字 母 表 示, 如 例 3.1 中 定 义 的 perimeter () 方 法 和 area() 方 法 但 当 方 法 名 由 多 个 英 文 单 词 组 成 时, 一 般 第 一 个 单 词 用 小 写, 后 面 每 个 单 词 的 首 字 母 都 大 写, 如 computeperimeter() computearea() 等 第 3 章 类 与 对 象 41

6 42 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 返 回 值 类 型 是 方 法 返 回 值 的 数 据 类 型 若 方 法 不 返 回 任 何 值, 则 返 回 值 类 型 为 关 键 字 void 除 构 造 方 法 外, 所 有 的 方 法 都 要 求 有 返 回 值 类 型 方 法 名 的 定 义 与 标 识 符 定 义 一 致, 最 好 能 够 体 现 方 法 的 含 义, 达 到 见 名 知 义 的 程 度 如 例 3.1 中, 可 以 定 义 专 门 操 作 成 员 变 量 的 方 法, 一 般 命 名 为 setxxx() 和 getxxx() 如 对 Rectangle 类 进 行 修 改, 增 加 4 个 专 门 用 于 操 作 成 员 变 量 的 方 法 : class Rectangle private float length=5.5f; private float width=3.5f; void setlength(float l) length=l; void setwidth(float w) width =w; float getlength() return length; float getwidth() return width; 在 增 加 的 4 个 方 法 中,setLength(float l) 和 setwidth(float w) 方 法 分 别 用 来 设 置 两 个 成 员 变 量 length 和 width 的 值 getlength() 和 getwidth() 方 法 分 别 用 来 获 取 两 个 成 员 变 量 length 和 width 的 值 由 于 两 个 成 员 变 量 的 访 问 权 限 被 定 义 为 private, 从 Rectangle 类 的 外 部 无 法 对 这 两 个 变 量 进 行 访 问, 程 序 中 提 供 了 两 组 set() 和 get() 方 法 用 于 对 两 个 成 员 变 量 进 行 读 写 操 作 如 只 设 置 get() 方 法, 那 么 该 变 量 对 外 来 说 是 只 读 的 ; 如 只 设 置 set() 方 法, 那 么 该 变 量 对 外 来 说 是 只 写 的 方 法 的 参 数 列 表 是 可 选 的 列 表 中 的 参 数 称 为 形 式 参 数, 简 称 为 形 参 当 方 法 被 调 用 时, 形 参 被 数 据 或 变 量 替 换, 这 些 数 据 或 变 量 称 为 实 际 参 数, 简 称 为 实 参 这 种 在 方 法 调 用 时 用 实 参 代 替 形 参 的 形 式, 称 为 参 数 传 递 如 果 希 望 方 法 有 返 回 值, 则 在 方 法 体 的 最 后 使 用 return xxx; 语 句, 终 止 方 法 并 返 回 一 个 值 给 该 方 法 的 调 用 者 在 类 体 中, 有 一 些 方 法 的 设 置 是 为 了 实 现 类 的 相 应 功 能, 如 例 3.1 中,perimeter() 方 法 和 area() 方 法 分 别 用 来 计 算 矩 形 的 周 长 和 面 积 这 些 方 法 往 往 是 类 对 象 的 功 能 体 现 成 员 方 法 也 可 加 访 问 权 限 修 饰 符, 用 来 限 定 该 方 法 的 使 用 范 围 成 员 方 法 的 访 问 权 限 修 饰 符 与 成 员 变 量 相 同, 共 有 4 种, 其 意 义 也 相 似 其 具 体 内 容 将 在 3.8 节 中 介 绍 4. 构 造 方 法 构 造 方 法 是 一 种 特 殊 方 法, 它 的 名 字 必 须 与 它 所 在 类 的 名 字 完 全 相 同, 并 且 不 返 回 任 何 数 据 类 型 Java 程 序 中 的 每 个 类 允 许 定 义 若 干 个 构 造 方 法, 但 这 些 构 造 方 法 的 参 数 必 须 不 同 每 个 类 都 有 一 个 默 认 的 构 造 方 法 ( 它 没 有 任 何 参 数 ), 如 果 类 没 有 重 新 定 义 构 造 方 法, 则 创 建 对 象 时 系 统 自 动 调 用 默 认 的 构 造 方 法 否 则, 创 建 对 象 时 调 用 自 定 义 的 构 造 方 法 在 例 3.1 中 的 Rectangle 类 中, 在 定 义 成 员 变 量 的 同 时 给 变 量 赋 了 初 值, 这 就 意 味 着 用 此 类 创 建 的 任 何 矩 形 对 象, 其 初 始 的 长 和 宽 都 是 一 样 的, 如 果 我 们 希 望 每 次 能 得 到 长 和 宽 都 不 一 样 的 矩 形 对 象, 又 该 如 何 来 设 计 呢? 请 看 下 面 的 程 序 :

7 class Rectangle private float length; private float width; public Rectangle() length=5.5f; width=3.5f; public Rectangle(float x, float y) length=x; width=y; 在 Rectangle 类 中, 增 加 了 两 个 构 造 方 法, 分 别 用 于 创 建 类 的 对 象 那 么, 在 测 试 类 Jpro3_1 中, 就 能 调 用 这 两 个 构 造 方 法 来 创 建 对 象, 程 序 代 码 如 下 : public class Jpro3_1 Rectangle r1=new Rectangle(); Rectangle r2=new Rectangle(); Rectangle r3=new Rectangle(2.4f,3.2f); Rectangle r4=new Rectangle(2.0f,3.5f); 每 次 调 用 无 参 构 造 方 法 所 创 建 的 矩 形 对 象 的 长 和 宽 都 有 一 个 固 定 的 初 值, 如 r1 和 r2 的 长 为 5.5, 宽 为 3.5 而 每 次 调 用 带 参 构 造 方 法 时, 只 要 实 参 不 同, 就 能 构 造 出 不 同 的 矩 形 对 象 如 r3 的 长 为 2.4, 宽 为 3.2;r4 的 长 为 2.0, 宽 为 main() 方 法 一 般 情 况 下, 要 使 用 一 个 类, 就 必 须 创 建 这 个 类 的 对 象 那 么, 对 象 的 创 建 是 应 该 设 计 在 同 一 个 类 中 还 是 设 计 在 另 一 个 类 中 呢? 答 案 是 两 者 都 可 以, 但 最 好 是 在 另 一 个 类 中 这 样, 没 有 对 象 定 义 的 纯 粹 的 类 设 计 部 分 就 可 以 单 独 保 存 在 一 个 文 件 中, 就 不 会 影 响 该 类 的 重 复 使 用 在 例 3.1 中, 矩 形 类 和 测 试 类 分 别 放 在 两 个 类 中 来 进 行 设 计, 就 是 类 重 复 使 用 思 想 的 体 现 由 于 main() 方 法 是 每 个 Java 应 用 程 序 执 行 的 入 口 方 法 因 此, 在 Jpro3_1 类 中 设 计 了 main() 方 法 main() 方 法 的 定 义 格 式 如 下 : public 修 饰 符 说 明 main() 方 法 可 以 为 所 有 类 访 问 static 修 饰 符 表 明 main() 方 法 是 静 态 方 法 main() 方 法 用 于 启 动 Java 应 用 程 序, 因 为 是 用 static 定 义 的, 当 应 用 程 序 启 动 后, 实 际 上 系 统 中 并 不 存 在 任 何 对 象, 可 以 直 接 调 用 因 此,main() 方 法 的 主 要 工 作 就 是 创 建 启 动 程 序 所 需 的 对 象 它 的 返 回 值 类 型 为 void, 即 无 实 际 返 回 值 args[] 是 形 式 参 数 第 3 章 类 与 对 象 43

8 44 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 3.3 对 象 对 象 (object) 是 以 类 作 为 模 板 创 建 的, 类 是 一 种 复 杂 数 据 类 型, 是 对 象 定 义 的 前 提 类 是 具 有 共 同 特 性 的 实 体 抽 象, 而 对 象 又 是 现 实 世 界 中 实 体 的 表 现 对 象 是 类 的 实 例 化, 对 象 和 实 例 (instance) 两 个 词 语 通 常 可 以 互 换 当 然, 实 例 也 可 理 解 为 类 的 具 体 实 现 类 和 对 象 的 关 系 是 一 般 与 个 别 的 关 系, 可 以 比 作 一 张 图 纸 和 多 幢 楼 房 之 间 的 关 系 两 种 : 对 象 的 创 建 对 象 的 创 建 过 程 实 际 上 就 是 类 的 实 例 化 过 程 创 建 对 象 须 使 用 操 作 符 new, 其 格 式 可 以 有 类 名 对 象 名 =new 类 名 ([ 参 数 1, 参 数 2, ]); 如 :Rectangle r1=new Rectangle(5.5f,3.5f); 或 者 类 名 对 象 名 ; 对 象 名 =new 类 名 ([ 参 数 1, 参 数 2, ]); 如 :Rectangle r1; r1=new Rectangle(5.5f,3.5f); 第 一 种 方 式, 将 对 象 的 声 明 和 创 建 合 并 在 一 起, 其 功 能 是 为 对 象 分 配 内 存 空 间, 然 后 执 行 构 造 方 法 中 的 语 句 为 成 员 变 量 赋 值, 最 后 将 所 分 配 存 储 空 间 的 首 地 址 赋 给 对 象 变 量 存 储 空 间 相 当 于 一 个 抽 屉, 数 据 放 在 抽 屉 中, 对 象 变 量 中 所 放 的 是 打 开 这 个 抽 屉 的 钥 匙 其 内 存 模 型 如 图 3-1(b) 所 示 第 二 种 方 式, 先 声 明 对 象 变 量, 对 象 变 量 声 明 后, 该 对 象 变 量 还 没 有 引 用 任 何 实 体, 我 们 称 这 时 的 对 象 为 空 对 象, 其 内 存 模 型 如 图 3-1(a) 所 示 空 对 象 必 须 再 用 new 运 算 符 分 配 实 体 后 才 能 使 用, 其 内 存 模 型 如 图 3-1(b) 所 示 r1 null r length width (a) 图 3-1 对 象 的 内 存 模 型 (b) 使 用 new 运 算 符 结 果 是 返 回 新 创 建 的 对 象 的 一 个 引 用 new 为 指 定 的 类 创 建 一 个 对 象 时, 首 先 为 该 对 象 在 内 存 中 分 配 内 存 空 间, 然 后 以 类 为 模 板 构 造 该 对 象, 最 后 把 该 对 象 在 内 存 中 的 首 地 址 返 回 给 对 象 名 这 样 我 们 就 可 以 像 使 用 一 个 普 通 变 量 一 样 通 过 对 象 名 来 使 用 对 象 同 时, 使 用 new 运 算 符 创 建 对 象 时, 也 调 用 了 该 类 的 构 造 方 法 实 现 对 象 的 初 始 化 一 个 类 使 用 new 运 算 符 可 以 创 建 多 个 不 同 的 对 象, 这 些 对 象 被 分 配 不 同 的 内 存 空 间, 因 此 改 变 一 个 对 象 的 内 存 状 态 不 会 影 响 其 他 对 象 的 内 存 状 态 例 如, 我 们 使 用 Rectangle 类 创 建 两 个 对 象 r1 和 r2, 其 内 存 模 型 如 图 3-2 所 示

9 Rectangle r1=new Rectangle(5.5f,3.5f); Rectangle r2=new Rectangle(2.4f,3.2f); r1 r2 5.5 length 2.4 length 3.5 width 3.2 width 图 3-2 多 个 对 象 的 内 存 模 型 对 象 的 使 用 一 旦 创 建 了 对 象, 就 可 以 使 用 对 象 编 写 程 序, 完 成 相 应 的 功 能 了 对 象 的 使 用 主 要 有 以 下 三 种 情 况 : 1. 使 用 对 象 的 成 员 变 量 和 成 员 方 法 对 象 不 仅 可 以 操 作 自 己 的 成 员 变 量 来 改 变 状 态, 而 且 还 可 以 使 用 类 中 的 方 法, 对 象 通 过 这 些 方 法 产 生 一 定 的 行 为 对 象 通 过 运 算 符. 来 引 用 自 己 的 成 员 如 例 3.1 中,main() 方 法 中 的 语 句 : r1.length=5.5f; r1.width=3.5f; double zc= r1.perimeter(); System.out.println(" 矩 形 的 周 长 是 :"+zc); System.out.println(" 矩 形 的 面 积 是 :"+r1.area()); 在 上 面 的 程 序 中, 当 方 法 有 返 回 值 时, 可 以 将 返 回 值 赋 给 相 同 类 型 的 变 量, 也 可 以 直 接 输 出 返 回 值 2. 对 象 间 的 赋 值 相 同 类 型 的 变 量 可 以 互 相 赋 值 如 果 两 个 对 象 有 相 同 的 值, 那 么 它 们 就 具 有 相 同 的 实 体, 即 指 向 同 一 个 内 存 空 间 如 以 下 语 句 : Rectangle r1=new Rectangle(5.5f,3.5f); Rectangle r2=new Rectangle(2.4f,3.2f); r1=r2; 执 行 赋 值 语 句 r1=r2 后,r1 和 r2 引 用 的 实 体 就 一 样 了, 即 r1 和 r2 指 向 同 一 个 存 储 空 间, r1 原 先 引 用 的 存 储 空 间 失 去 了 引 用 对 象, 变 成 了 一 块 垃 圾 内 存, 其 内 存 模 型 如 图 3-3 所 示 此 时 r1 和 r2 的 成 员 完 全 相 同, 其 值 也 相 同 r1 r2 5.5 length 2.4 length 3.5 width 3.2 width 图 3-3 对 象 赋 值 后 的 内 存 模 型 3. 把 对 象 作 为 方 法 的 参 数 对 象 也 可 以 像 变 量 一 样, 作 为 方 法 的 参 数 使 用 第 3 章 类 与 对 象 45

10 46 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 例 3.2 分 别 定 义 两 个 类 : 点 类 和 圆 类, 将 点 类 对 象 作 为 圆 类 的 成 员 变 量, 并 编 写 测 试 类 进 行 功 能 测 试 // 文 件 名 Jpro3_2.java class Point int x; int y; Point(int a,int b) x=a; y=b; class Circle int radius; Point point; // 定 义 引 用 型 成 员 变 量 Circle(int r,point p) // 形 参 为 引 用 型 的 变 量 radius=r; point=p; // 引 用 型 变 量 赋 值 void output() System.out.println(" 圆 的 半 径 是 :"+radius); System.out.println(" 圆 的 圆 心 是 :"+"("+point.x+","+point.y+")"); public class Jpro3_2 Point p1=new Point(1,2); Circle c=new Circle(5,p1); // 实 参 为 对 象 变 量 c.output(); 程 序 运 行 结 果 为 : 圆 的 半 径 是 :5 圆 的 圆 心 是 :(1,2) 程 序 分 析 : 例 3.2 定 义 了 一 个 点 类 Point, 一 个 圆 类 Circle, 一 个 测 试 类 Jpro3_2 Circle 类 的 成 员 变 量 point 的 类 型 为 Point, 因 此 其 构 造 方 法 中 必 须 有 这 个 相 应 的 参 数 Point p 来 给 成 员 变 量 point 赋 初 值 测 试 类 Jpro3_2 首 先 要 创 建 一 个 Point 对 象 p1, 然 后 将 p1 作 为 构 造 方 法 Circle(5,p1) 的 实 参 去 创 建 Circle 对 象 c 那 么 实 参 p1 传 递 给 形 参 p 是 什 么 呢? 是 对 象 变 量 本 身 所 存 储 的 内 容, 即 所 引 用 对 象 的 内 存 空 间 的 首 地 址, 而 不 是 所 引 用 的 实 体 的 内 容

11 3.3.3 垃 圾 对 象 的 回 收 当 对 象 被 创 建 时, 就 会 在 Java 虚 拟 机 的 堆 区 中 拥 有 一 块 内 存, 在 Java 虚 拟 机 的 生 命 周 期 中,Java 程 序 会 陆 续 地 创 建 多 个 对 象, 如 果 所 有 的 对 象 都 永 久 占 有 内 存, 那 么 内 存 有 可 能 很 快 被 消 耗, 引 发 内 存 空 间 不 足 因 此, 必 须 采 取 一 种 措 施 及 时 回 收 那 些 无 用 对 象 占 用 的 内 存, 以 保 证 内 存 可 以 被 重 复 利 用 Java 虚 拟 机 提 供 了 一 个 系 统 级 的 垃 圾 回 收 器 线 程, 它 负 责 自 动 回 收 那 些 无 用 对 象 所 占 用 的 内 存, 这 种 内 存 回 收 的 过 程 被 称 为 垃 圾 回 收 图 3-3 中,r1 和 r2 是 Rectangle 类 的 两 个 对 象, 分 别 指 向 两 个 实 体, 占 用 不 同 的 内 存 空 间, 如 果 执 行 语 句 : r1=r2; 则 r1 与 r2 均 指 向 r2 所 引 用 的 内 存 空 间, 而 r1 以 前 指 向 的 内 存 空 间 将 成 为 垃 圾 内 存 Java 虚 拟 机 会 自 动 回 收 这 个 没 用 的 对 象 空 间 3.4 成 员 变 量 实 例 变 量 和 类 变 量 类 有 两 种 不 同 类 型 的 成 员 变 量 : 实 例 变 量 和 类 变 量 类 变 量 又 称 为 静 态 变 量 用 关 键 字 static 修 饰 的 成 员 变 量 称 为 类 变 量, 而 没 有 用 关 键 字 static 修 饰 的 成 员 变 量 称 为 实 例 变 量 例 如 下 面 A 类 中,x 是 实 例 变 量, 而 y 是 类 变 量 class A float x; // 实 例 变 量 定 义 static int y; // 类 变 量 定 义 具 体 来 说, 实 例 变 量 和 类 变 量 的 主 要 区 别 为 : 1 在 内 存 分 配 的 空 间 上 不 同 对 象 的 同 名 实 例 变 量 分 配 不 同 的 内 存 空 间, 变 量 之 间 的 取 值 互 不 影 响 ; 不 同 对 象 的 同 名 类 变 量 分 配 相 同 的 内 存 空 间, 也 就 是 说 多 个 对 象 共 享 类 变 量, 改 变 其 中 一 个 对 象 的 类 变 量 的 值 会 影 响 其 他 对 象 中 相 应 的 类 变 量 的 值 2 在 内 存 分 配 的 时 间 上 当 类 的 字 节 码 文 件 被 加 载 到 内 存 时, 类 变 量 就 分 配 了 相 应 的 内 存 空 间 ; 实 例 变 量 是 当 类 的 对 象 创 建 时 才 会 被 分 配 内 存 名 访 问 3 访 问 方 式 不 同 实 例 变 量 必 须 用 对 象 名 访 问 ; 类 变 量 可 以 用 类 名 访 问, 也 可 以 用 对 象 例 3.3 编 写 一 个 矩 形 类, 用 类 变 量 统 计 所 创 建 的 矩 形 对 象 的 个 数 // 文 件 名 Jpro3_3.java class Rectangle private float length; private float width; static int number=0; // 定 义 类 变 量 Rectangle(float l, float w) 第 3 章 类 与 对 象 47

12 48 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) length=l; width=w; number++; // 改 变 类 变 量 的 值 public class Jpro3_3 // 用 两 种 方 式 访 问 类 变 量 System.out.println(" 当 前 矩 形 对 象 的 个 数 为 :"+Rectangle.number); Rectangle r1=new Rectangle(1.0f,2.0f); System.out.println(" 当 前 矩 形 对 象 的 个 数 为 :"+r1.number); Rectangle r2=new Rectangle(2.0f,2.5f); System.out.println(" 当 前 矩 形 对 象 的 个 数 为 :"+r1.number); System.out.println(" 当 前 矩 形 对 象 的 个 数 为 :"+r2.number); System.out.println(" 当 前 矩 形 对 象 的 个 数 为 :"+Rectangle.number); 程 序 运 行 结 果 : 当 前 矩 形 对 象 的 个 数 为 :0 当 前 矩 形 对 象 的 个 数 为 :1 当 前 矩 形 对 象 的 个 数 为 :2 当 前 矩 形 对 象 的 个 数 为 :2 当 前 矩 形 对 象 的 个 数 为 :2 程 序 分 析 : main() 方 法 的 第 一 条 语 句 被 执 行 时, 系 统 首 先 将 Rectangle 类 加 载 到 内 存, 并 为 类 变 量 number 分 配 了 内 存 空 间, 此 时, 就 可 以 用 类 名 Rectangle 直 接 引 用 类 变 量 number; 当 执 行 了 下 面 两 句 : Rectangle r1=new Rectangle(1.0f,2.0f); Rectangle r2=new Rectangle(2.0f,2.5f); 系 统 创 建 了 矩 形 对 象 r1 和 r2 后, 才 用 对 象 r1 和 r2 来 引 用 类 变 量 number, 但 这 种 方 式 并 不 提 倡 使 用, 因 为 其 可 读 性 较 差 从 最 后 三 条 语 句 的 输 出 结 果 也 可 看 出,r1 r2 和 Rectangle 共 享 类 变 量 number 常 量 如 果 一 个 类 的 成 员 变 量 前 加 final 修 饰 符, 该 成 员 变 量 就 为 常 量, 常 量 的 名 字 习 惯 用 大 写 字 母 表 示, 如 final double PI= ; 常 量 不 占 用 内 存, 这 意 味 着 在 声 明 常 量 时, 必 须 初 始 化 对 象 可 以 使 用 常 量, 但 不 能 更 改 它 的 值 例 3.4 已 知 圆 的 半 径, 求 圆 的 面 积 // 文 件 名 Jpro3_4.java class Circle

13 float radius; final float PI=3.14f; // 定 义 常 量 Circle (float r) radius=r; float area() return PI*radius*radius; public class Jpro3_4 Circle t=new Circle (0.5f); System.out.println(" 圆 面 积 是 :"+t.area()); 程 序 运 行 结 果 为 : 圆 面 积 是 : 成 员 方 法 实 例 方 法 和 类 方 法 类 有 两 种 不 同 类 型 的 成 员 方 法 : 实 例 方 法 和 类 方 法 类 方 法 又 称 为 静 态 方 法 用 关 键 字 static 修 饰 的 成 员 方 法 称 为 类 方 法, 而 没 有 用 关 键 字 static 修 饰 的 成 员 方 法 称 为 实 例 方 法 在 例 3.3 中, 如 将 静 态 变 量 number 定 义 为 私 有 成 员, 则 在 其 测 试 类 Jpro3_3 中 不 能 直 接 访 问 number, 若 要 在 Rectangle 类 定 义 一 个 方 法 来 访 问 number, 该 方 法 必 须 定 义 为 静 态 方 法 例 3.5 定 义 静 态 方 法 访 问 静 态 变 量 // 文 件 名 Jpro3_5.java class Rectangle private float length; private float width; private static int number; Rectangle(float l, float w) length=l; width=w; number++; public static void print() // 定 义 静 态 方 法 访 问 静 态 变 量 System.out.println(" 当 前 矩 形 对 象 的 个 数 为 :"+number); 第 3 章 类 与 对 象 49

14 50 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) public class Jpro3_5 Rectangle.print(); Rectangle r1=new Rectangle(1.0f,2.0f); Rectangle r2=new Rectangle(2.0f,2.5f); Rectangle.print(); 程 序 运 行 结 果 为 : 当 前 矩 形 对 象 的 个 数 为 :0 当 前 矩 形 对 象 的 个 数 为 :2 具 体 来 说, 实 例 方 法 和 类 方 法 的 主 要 区 别 为 : 1 在 内 存 分 配 的 时 间 上 当 类 的 字 节 码 文 件 被 加 载 到 内 存 时, 类 方 法 就 分 配 了 相 应 的 入 口 地 址 ; 实 例 方 法 是 当 类 的 对 象 创 建 时 才 会 被 分 配 入 口 地 址 访 问 2 访 问 方 式 不 同 实 例 方 法 必 须 用 对 象 名 访 问 ; 类 方 法 一 般 用 类 名 访 问, 也 可 用 对 象 名 3 操 作 的 对 象 不 同 类 方 法 只 能 操 作 类 变 量, 不 能 操 作 实 例 变 量 ; 而 实 例 方 法 既 可 以 操 作 类 变 量 也 可 以 操 作 实 例 变 量 4 另 外, 实 例 方 法 中 可 以 调 用 实 例 方 法 和 类 方 法, 而 类 方 法 中 只 能 调 用 类 方 法, 不 能 调 用 实 例 方 法 方 法 中 的 参 数 传 递 当 方 法 被 调 用 时, 如 果 方 法 有 参 数, 参 数 变 量 必 须 有 具 体 的 值 如 例 3.2 中 的 两 个 构 造 方 法 : Point(int a,int b) x=a; y=b; Circle(int r,point p) radius=r; point=p; 其 调 用 语 句 为 : Point p1=new Point(1,2); Circle c=new Circle(5,p1); 方 法 声 明 中 设 计 的 参 数 称 为 形 式 参 数 或 形 参, 如 int a int b 和 int r Point p 调 用 方 法 时 所 传 递 的 参 数 称 为 实 际 参 数 或 实 参 实 参 可 以 是 一 个 常 量, 如 Point(1,2) 中 的 1 2, 也 可 以 是 一 个 已 赋 值 的 基 本 数 据 类 型 的 变 量, 如 : int a=1; int b=2; Point p1=new Point(a,b);

15 实 数 还 可 以 是 一 个 引 用 类 型 的 对 象, 如 Circle(5,p1) 中 的 p1 调 用 方 法 时, 实 参 的 值 传 递 给 形 参 不 管 参 数 是 何 类 型, 传 递 时 都 是 按 值 传 递, 下 面 分 两 种 情 况 进 行 说 明 1. 基 本 数 据 类 型 参 数 的 传 值 对 于 基 本 数 据 类 型 的 参 数, 实 参 数 据 类 型 的 级 别 不 能 高 于 形 参 的 级 别 比 如, 不 能 向 int 类 型 的 形 参 传 递 一 个 float 类 型 的 值, 但 可 以 向 double 类 型 形 参 传 递 一 个 float 类 型 的 值 如 将 例 3.2 中 的 语 句 : Point p1=new Point(1,2); 改 为 Point p1=new Point(1.5f,2); 则 程 序 不 能 通 过 编 译 另 外, 改 变 形 参 变 量 的 内 容, 实 参 的 内 容 不 会 跟 着 变 化 例 3.6 当 方 法 的 类 型 为 基 本 数 据 类 型 时, 改 变 形 参 变 量 的 内 容, 实 参 的 内 容 不 会 跟 着 变 化 // 文 件 名 Jpro3_6.java class A void a(int a) a=10; System.out.println("a="+a); public class Jpro3_6 A a1=new A(); int x=5; a1.a(x); System.out.println("x="+x); 程 序 运 行 结 果 为 : a=10 x=5 程 序 分 析 : 实 参 x 的 值 为 5, 当 对 象 a1 调 用 方 法 a() 时,x 将 5 传 递 给 形 参 a,a 的 值 就 为 5 在 方 法 a() 中, 将 a 赋 值 为 10, 此 时,x 的 值 并 没 有 改 变, 仍 为 5 2. 引 用 类 型 参 数 的 传 值 引 用 类 型 数 据 包 括 对 象 数 组 以 及 接 口 等 当 方 法 的 参 数 是 引 用 类 型 时, 实 参 传 递 的 是 对 象 的 引 用, 而 不 是 对 象 的 内 容 当 实 参 的 值 传 递 给 形 参 时, 实 参 和 形 参 对 象 都 指 向 同 一 个 存 储 空 间 如 果 改 变 形 参 所 引 用 实 体 的 内 容, 实 参 所 引 用 实 体 的 内 容 也 会 跟 着 变 化 例 3.7 引 用 类 型 参 数 的 传 值 // 文 件 名 Jpro3_7.java 第 3 章 类 与 对 象 51

16 52 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) class Point int x; int y; Point(int a,int b) x=a; y=b; class Circle int r; Point point; Circle(int r1,point p1) r=r1; //p1.x=10; // 改 变 p1 的 坐 标 //p1.y=10; point=p1; void output() point.x=10; // 改 变 point 的 坐 标 point.y=10; System.out.println(" 圆 心 的 坐 标 是 :"+"("+point.x+","+point.y+")"); public class Jpro3_7 Point p=new Point(1,2); System.out.println(" 点 的 坐 标 是 :"+"("+p.x+","+p.y+")"); Circle c=new Circle(5,p); c.output(); System.out.println(" 点 的 坐 标 是 :"+"("+p.x+","+p.y+")"); 程 序 的 运 行 结 果 为 : 点 的 坐 标 是 :(1,2) 圆 心 的 坐 标 是 :(10,10) 点 的 坐 标 是 :(10,10) 程 序 分 析 : 首 先 定 义 了 一 个 坐 标 为 (1,2) 的 点 对 象 p, 把 p 作 为 实 参 创 建 一 个 圆 对 象 c, 将 实 参 p 的 值 传 递 给 了 形 参 p1, 不 管 是 在 构 造 方 法 中 改 变 p1 的 坐 标, 还 是 在 output() 方 法 中 改 变 point 的 坐 标,p 的 坐 标 都 会 随 之 改 变

17 3.6 关 键 字 this this 是 Java 中 的 关 键 字, 代 表 本 类 对 象, 下 面 从 两 个 方 面 介 绍 它 的 应 用 1. 使 用 this 区 分 成 员 变 量 和 局 部 变 量 在 方 法 体 中 声 明 的 变 量 以 及 方 法 的 参 数 称 为 局 部 变 量, 方 法 的 参 数 在 整 个 方 法 内 有 效, 方 法 内 定 义 的 局 部 变 量 从 它 定 义 的 位 置 之 后 开 始 有 效 成 员 变 量 在 整 个 类 内 有 效 在 一 个 类 中, 如 果 出 现 局 部 变 量 的 名 字 与 成 员 变 量 的 名 字 相 同, 则 成 员 变 量 被 隐 藏, 即 这 个 成 员 变 量 在 这 个 方 法 内 暂 时 失 效 例 如 : class Rectangle private double length; private double width; Rectangle(double length,double width) length= length; // 成 员 变 量 被 隐 藏 width=width; 如 果 希 望 成 员 变 量 length 被 成 功 赋 值, 必 须 在 成 员 变 量 前 加 this,this.length 表 示 当 前 对 象 的 成 员 变 量 length, 而 不 是 局 部 变 量 length 例 如 : class Rectangle private double length; private double width; Rectangle(double length,double width) this.length= length; // 给 成 员 变 量 length 赋 值 this.width=width; // 给 成 员 变 量 width 赋 值 2. 用 this 调 用 本 类 中 的 其 他 构 造 方 法 在 构 造 方 法 中 用 this 调 用 本 类 中 的 其 他 构 造 方 法, 调 用 时 要 放 在 构 造 方 法 的 首 行 如 : class Rectangle private float length; private float width; public Rectangle() this(5.5f,3.5f); // 调 用 了 带 参 构 造 方 法 public Rectangle(float x, float y) length=x; width=y; 第 3 章 类 与 对 象 53

18 54 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 3. 实 例 方 法 中 可 以 使 用 this, 类 方 法 中 不 可 使 用 this 实 例 方 法 中 使 用 this 来 引 用 的 成 员 表 示 为 当 前 对 象 的 成 员, 通 常 情 况 省 略 不 写, 其 含 义 相 同 类 方 法 中 不 可 使 用 this, 因 为 类 方 法 可 以 通 过 类 名 直 接 调 用, 这 时 可 能 还 没 有 创 建 任 何 对 象 例 如 : class R int x; void f() this.x=100; this.g(); void g() x=200; //this 可 以 省 略 //this 可 以 省 略 3.7 内 部 类 类 可 以 嵌 套 定 义, 即 在 一 个 类 的 类 体 中 可 以 嵌 套 定 义 另 外 一 个 类 被 嵌 套 的 类 称 为 内 部 类, 它 的 上 级 称 为 外 部 类 内 部 类 中 还 可 以 再 嵌 套 另 一 个 类, 在 最 外 层 的 类 被 称 为 顶 层 类 内 部 类 的 创 建 方 法 与 外 部 类 相 似 除 外 部 类 外, 其 他 类 无 法 访 问 内 部 类 当 一 个 类 只 在 某 个 类 中 使 用, 并 且 不 允 许 除 外 部 类 外 的 其 他 类 访 问 时, 可 考 虑 把 该 类 设 计 成 内 部 类 例 3.8 内 部 类 的 使 用 // 文 件 名 Outer.java class Outer private int index=100; class Inner private int index=50; void print() int index=30; System.out.println(index); System.out.println(this.index); System.out.println(Outer.this.index); void print() Inner inner=new Inner(); inner.print(); Inner getinner() return new Inner(); // 外 部 类 成 员 // 内 部 类 成 员 // 内 部 类 局 部 变 量 // 输 出 内 部 类 局 部 变 量 // 输 出 内 部 类 成 员 变 量 // 输 出 外 部 类 成 员 变 量 // 创 建 内 部 类 对 象 // 调 用 内 部 类 方 法 // 创 建 匿 名 内 部 类 对 象

19 Outer outer=new Outer(); outer.print(); Inner inner=outer.getinner(); inner.print(); 程 序 运 行 结 果 为 : 程 序 分 析 : // 创 建 外 部 类 对 象 // 创 建 内 部 类 对 象 在 外 部 类 Outer 中 定 义 了 一 个 内 部 类 Inner, 外 部 类 对 象 outer 调 用 的 print() 方 法 是 自 己 的 方 法 要 调 用 内 部 类 的 print() 方 法, 必 须 先 构 造 内 部 类 对 象 内 部 类 调 用 getinner() 方 法, 该 方 法 用 匿 名 的 方 式 创 建 了 一 个 内 部 类 对 象 格 式 为 : 若 将 main() 方 法 放 在 另 一 个 类 Jpro3_8 中, 那 么, 创 建 内 部 类 对 象 的 方 式 将 会 改 变, 基 本 外 部 类. 内 部 类 内 部 类 对 象 = 外 部 类 对 象.new 内 部 类 (); 程 序 如 下 : // 文 件 名 Jpro3_8.java public class Jpro3_8 Outer outer=new Outer(); outer.print(); Outer.Inner inner=outer.new Inner(); // 创 建 内 部 类 对 象 inner.print(); 还 有 一 种 类 称 为 匿 名 内 部 类, 是 指 可 以 利 用 内 部 类 创 建 无 名 对 象, 并 利 用 它 访 问 类 里 的 成 员 匿 名 内 部 类 的 创 建 不 同 于 普 通 的 内 部 类 的 创 建, 不 需 要 定 义 类 名, 直 接 用 new 创 建 对 象 如 上 例 中 的 getinner() 方 法 中 的 语 句 : Inner getinner() return new Inner(); // 创 建 匿 名 内 部 类 对 象 匿 名 内 部 类 的 应 用 主 要 是 简 化 程 序 代 码 在 Java 的 窗 口 程 序 设 计 中, 常 会 利 用 匿 名 内 部 类 的 技 术 编 写 事 件 的 程 序 代 码, 具 体 应 用 请 参 见 第 11 章 第 3 章 类 与 对 象 55

20 56 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 3.8 自 定 义 包 包 (package) 是 Java 提 供 的 类 的 组 织 方 式 一 个 包 对 应 一 个 文 件 夹, 一 个 包 中 可 以 放 置 许 多 类 文 件 和 子 包 Java 语 言 可 以 把 类 文 件 存 放 在 不 同 层 次 的 包 中, 其 目 的 是 在 设 计 软 件 系 统 时, 当 系 统 中 的 类 较 多, 就 可 以 分 类 存 放 不 同 的 类 文 件, 从 而 大 大 方 便 软 件 的 维 护 和 资 源 的 重 用 Java 语 言 规 定 : 同 一 个 包 中 的 文 件 名 必 须 唯 一, 不 同 包 中 的 文 件 名 可 以 相 同 包 的 组 织 方 式 和 表 现 方 式 与 Windows 中 的 文 件 和 文 件 夹 完 全 相 同 JDK 中 提 供 许 多 系 统 包, 只 要 正 确 安 装 了 JDK 文 件, 在 Java 环 境 下 就 可 以 使 用 系 统 包 中 的 文 件, 关 于 系 统 包 中 的 相 关 内 容 将 在 第 7 章 中 介 绍 创 建 包 定 义 包 语 句 的 格 式 为 : package < 包 名 >; 其 中,package 是 包 的 关 键 字,< 包 名 > 是 包 的 标 识 符 package 语 句 指 出 该 语 句 所 在 的 Java 源 文 件 中 的 所 有 类 编 译 后 所 存 放 的 位 置 Java 文 件 规 定, 如 果 一 个 Java 源 程 序 中 有 package 语 句, 那 么 package 语 句 必 须 写 在 Java 源 程 序 的 第 一 行 如 : package mypackage; public class a 如 果 源 程 序 中 省 略 了 package 语 句, 那 么 源 文 件 中 的 类 经 编 译 后 放 在 与 源 程 序 相 同 的 一 个 无 名 包 中 一 个 包 中 还 可 以 定 义 子 包, 可 由 标 识 符 加. 分 割 而 成, 如 : package china.anhui.hefei; package sun.com.cn; 如 果 在 china.anhui.hefei 包 中 存 放 一 个 名 叫 Student 的 类, 则 该 类 的 全 名 应 为 : china.anhui.hefei.student 使 用 包 包 中 存 放 的 是 编 译 后 的 字 节 码 文 件 用 户 可 以 在 编 程 时, 通 过 import 语 句 导 入 包 中 的 类, 从 而 直 接 使 用 导 入 的 类 import 语 句 的 使 用 分 两 种 情 况 : 1 导 入 某 个 包 中 的 所 有 类, 如 : import mypackage.*; 2 导 入 某 个 包 中 的 一 个 类, 如 : import mypackage.student; 注 意 : 导 入 的 类 是 要 占 用 内 存 空 间 的, 当 某 包 中 的 类 很 多, 而 用 到 的 类 也 很 多 时, 就 用

21 方 式 1 导 入 ; 当 某 包 中 的 类 很 多, 而 要 用 的 类 却 很 少 时, 就 用 方 式 2 导 入 当 用 方 式 1 导 入 类 时, 如 包 中 还 有 子 包, 则 子 包 中 的 类 不 会 被 导 入 例 3.9 修 改 例 3.2, 将 Point 类 放 到 point 包 中, 并 用 文 件 名 Point.java 保 存 ; 将 Circle 类 放 到 circle 包 中, 并 用 文 件 名 Circle.java 保 存 ; 将 Jpro3_9 类 用 文 件 名 Jpro3_9.java 保 存 修 改 后 的 程 序 如 下 : //Point.java package point; // 定 义 包 public class Point public int x; public int y; public Point(int a,int b) x=a; y=b; Point.java 编 译 后, 产 生 文 件 夹 point, 在 point 文 件 夹 中 生 成 类 文 件 Point.class //Circle.java package circle; // 定 义 包 import point.point; // 导 入 Point 类 public class Circle int r; Point p; public Circle(int r1,point p1) r=r1; p=p1; public void output() System.out.println(" 圆 的 半 径 是 :"+r); System.out.println(" 圆 的 圆 心 是 :"+"("+p.x+","+p.y+")"); Circle.java 编 译 后, 产 生 文 件 夹 circle, 在 circle 文 件 夹 中 生 成 类 文 件 Circle.class // Jpro3_9.java import point.point; // 导 入 Point 类 import circle.circle; // 导 入 Circle 类 public class Jpro3_9 Point p=new Point(1,2); Circle c=new Circle(5,p); c.output(); 程 序 分 析 : 程 序 的 输 出 同 例 3.2, 但 由 于 三 个 类 不 在 同 一 个 包 中, 被 导 入 的 类 的 访 问 权 限 必 须 是 第 3 章 类 与 对 象 57

22 58 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) public, 被 导 入 的 类 的 成 员 要 想 被 访 问 到, 其 访 问 权 限 也 要 随 之 改 变 注 意 : 在 实 际 操 作 时, 要 将 Point.java Circle.java Jpro3_9.java 放 在 同 一 个 文 件 夹 下 3.9 访 问 权 限 当 类 存 放 到 不 同 的 包 中 时, 对 类 及 其 成 员 的 访 问 将 受 到 其 访 问 权 限 的 限 制 Java 中 的 访 问 权 限 修 饰 符 有 :private( 私 有 的 ) protected( 受 保 护 的 ) public( 公 有 的 ) 和 缺 省 的 ( 不 加 任 何 访 问 修 饰 符 ) 类 与 构 造 方 法 的 访 问 权 限 1.public 类 和 友 好 类 对 类 的 访 问 权 限 的 控 制 只 有 两 种 : 一 种 是 加 public 修 饰 符 例 如 : public class A 用 public 修 饰 符 修 饰 的 类 称 为 公 共 类, 公 共 类 可 以 被 任 何 包 中 的 类 访 问 另 一 种 是 不 加 任 何 访 问 权 限 修 饰 符, 例 如 : class A 这 样 的 类 被 称 为 友 好 类 如 果 在 另 一 个 类 中 使 用 友 好 类, 一 定 要 保 证 它 们 在 同 一 个 包 中 2. 构 造 方 法 的 访 问 权 限 类 中 默 认 构 造 方 法 的 访 问 权 限 和 类 的 访 问 权 限 保 持 一 致 当 用 户 自 定 义 构 造 方 法 时, 也 要 保 证 其 访 问 权 限 与 类 相 同 因 此, 构 造 方 法 一 般 只 用 public 和 缺 省 两 种 权 限 修 饰 符 当 public 类 的 构 造 方 法 的 访 问 权 限 缺 省 时, 在 不 同 包 的 类 中, 是 不 能 用 此 构 造 方 法 来 创 建 对 象 的 成 员 变 量 和 成 员 方 法 的 访 问 权 限 1. 私 有 的 变 量 和 方 法 用 关 键 字 private 修 饰 的 成 员 变 量 和 成 员 方 法 被 称 为 私 有 变 量 和 私 有 方 法 如 : class A private int x; private void printx() 私 有 的 成 员 只 在 本 类 中 有 效, 只 有 在 本 类 中 创 建 该 类 的 对 象 时, 这 个 对 象 才 能 访 问 自 己 的 私 有 成 员 从 类 的 封 装 性 来 说, 成 员 变 量 大 多 定 义 为 私 有, 而 成 员 方 法 往 往 是 类 的 对 外 访 问 接 口, 定 义 为 私 有 就 失 去 了 意 义

23 2. 公 有 的 变 量 和 方 法 用 关 键 字 public 修 饰 的 成 员 变 量 和 成 员 方 法 被 称 为 公 有 变 量 和 公 有 方 法 如 : public class A public int x; public void printx() 公 有 的 变 量 和 方 法 通 常 定 义 在 公 共 类 中, 不 管 是 否 处 于 同 一 个 包, 公 共 类 对 象 能 访 问 自 己 的 公 有 的 变 量 和 方 法 3. 友 好 的 变 量 和 方 法 不 使 用 任 何 访 问 权 限 修 饰 符 修 饰 的 成 员 变 量 和 成 员 方 法 被 称 为 友 好 变 量 和 友 好 方 法 如 : class A int x; void printx() class B void g() A a=new A(); a.x=10; a.printx(); 友 好 成 员 通 常 定 义 在 友 好 类 中, 友 好 成 员 的 有 效 范 围 是 同 包 中 的 类 若 类 A 与 类 B 定 义 在 同 一 个 源 文 件 中, 那 么 编 译 后, 类 A 与 类 B 为 同 一 个 包 中 的 类 此 时, 在 B 类 中 用 A 类 创 建 的 对 象 可 直 接 引 用 其 友 好 的 成 员 4. 受 保 护 的 变 量 和 方 法 用 关 键 字 protected 修 饰 的 成 员 变 量 和 成 员 方 法 被 称 为 受 保 护 的 变 量 和 受 保 护 的 方 法 如 : public class A protected int x; protected void printx() 受 保 护 的 成 员 通 常 用 在 父 类 与 子 类 之 间, 体 现 了 继 承 的 概 念 对 于 同 一 个 包 中 的 类, 受 保 护 的 成 员 的 用 法 与 友 好 成 员 相 同, 对 于 不 同 包 中 的 类, 只 有 子 类 对 象 才 能 访 问 受 保 护 的 成 员 第 3 章 类 与 对 象 59

24 60 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) 其 具 体 用 法 将 在 第 4 章 中 介 绍 3.10 泛 型 类 泛 型 (Generics) 是 JDK 1.5 的 新 特 性, 泛 型 的 本 质 是 参 数 化 类 型, 也 就 是 说 所 操 作 的 数 据 类 型 被 指 定 为 一 个 参 数 这 种 参 数 类 型 可 以 用 在 类 接 口 和 方 法 的 创 建 中, 分 别 称 为 泛 型 类 泛 型 接 口 泛 型 方 法 Java 语 言 引 入 泛 型 的 好 处 是 安 全 简 单 在 JDK1.5 之 前, 在 没 有 泛 型 的 情 况 下, 是 通 过 对 类 型 Object 的 引 用 来 实 现 参 数 的 任 意 化 任 意 化 带 来 的 缺 点 是 要 做 显 式 的 强 制 类 型 转 换, 而 这 种 转 换 是 要 求 开 发 者 对 实 际 参 数 类 型 可 以 预 知 的 情 况 下 进 行 的 对 于 强 制 类 型 转 换 错 误 的 情 况, 编 译 器 可 能 不 提 示 错 误, 在 运 行 的 时 候 才 出 现 异 常, 这 是 一 个 安 全 隐 患 1. 泛 型 类 声 明 声 明 泛 型 类 的 一 般 格 式 为 : class 类 名 < 泛 型 列 表 > 如 : class A<E,F> 其 中,A 是 泛 型 类 的 名 称,E F 是 泛 型 类 的 参 数, 也 就 是 说, 泛 型 类 的 参 数 类 型 没 有 指 定 它 可 以 是 任 何 引 用 类 型, 但 不 能 是 基 本 数 据 类 型 泛 型 类 声 明 时, 其 参 数 类 型 可 能 作 为 类 成 员 变 量 和 成 员 方 法 的 类 型 2. 泛 型 类 的 使 用 例 3.10 计 算 锥 体 的 体 积 分 析 : 要 计 算 锥 体 的 体 积, 必 须 知 道 锥 体 底 的 形 状 假 设 锥 体 的 底 是 圆 正 方 形 和 矩 形 等 形 状, 其 底 面 的 面 积 可 以 计 算 出 来 于 是 设 计 一 个 计 算 锥 体 体 积 的 泛 型 类, 其 参 数 为 底 的 形 状 // 文 件 名 Jpro3_10.java class Cone<E> // 定 义 泛 型 类 double height; E bottom; // 定 义 泛 型 变 量 public Cone(E e) bottom=e; public void volume() String s=bottom.tostring(); double area=double.parsedouble(s); System.out.println(" 体 积 是 :"+1.0/3.0*area*height); class Circle double radius; Circle(double r)

25 radius=r; public String tostring() // 覆 盖 tostring 方 法 return ""+radius*radius*math.pi; class Square double side; Square(double s) side=s; public String tostring() // 覆 盖 tostring 方 法 return ""+side*side; public class Jpro3_10 Circle circle=new Circle(10); Cone<Circle> coneone=new Cone<Circle>(circle); // 创 建 一 个 ( 圆 ) 锥 对 象 coneone.height=30; coneone.volume(); Square square=new Square(10); Cone<Square> conetwo=new Cone<Square>(square); // 创 建 一 个 ( 方 ) 锥 对 象 conetwo.height=10; conetwo.volume(); 程 序 运 行 结 果 为 : 体 积 是 : 体 积 是 : 程 序 分 析 : 每 个 类 都 是 Object 类 的 子 类,Object 类 中 有 一 个 tostring() 方 法, 因 此, 所 有 的 类 都 有 一 个 从 Object 类 继 承 的 tostring() 方 法, 本 例 正 是 运 用 了 tostring() 方 法 返 回 锥 底 的 面 积 3.11 实 例 例 3.11 打 印 某 个 日 期, 并 判 断 该 年 是 否 是 闰 年 分 析 : 日 期 有 年 月 日 三 个 基 本 属 性, 因 此 所 设 计 的 日 期 类 应 有 三 个 私 有 的 成 员 变 量, 要 构 造 日 期 对 象, 带 参 的 构 造 方 法 是 必 不 可 少 的 针 对 私 有 的 成 员 变 量, 应 设 计 一 组 get 和 set 方 法 来 存 取 私 有 的 成 员 变 量 的 值 另 外, 输 出 一 个 日 期 的 方 法 和 判 断 某 年 是 否 是 闰 年 的 成 员 方 法 也 是 必 需 的 第 3 章 类 与 对 象 61

26 62 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) // 文 件 名 Jpro3_11.java class Date private int year; // 成 员 变 量, 表 示 年 private int month; // 成 员 变 量, 表 示 月 private int day; // 成 员 变 量, 表 示 日 public Date(int y, int m, int d) // 构 造 方 法 year = y; month = m; day = d; public void setdate(int y, int m, int d) // 设 置 日 期 值 year = y; month = m; day = d; public int getyear() return year; public int getmonth() return month; public int getday() return day; public void Print() // 输 出 日 期 值 System.out.println("date is "+year+'-'+month+'-'+day); public boolean isleapyear() // 判 断 是 否 闰 年 return (year%400==0) (year%100!=0) & (year%4==0); public class Jpro3_11 Date a = new Date(2010,10,1); // 创 建 对 象 a.print(); if(a.isleapyear()) System.out.println(a.getYear()+" 是 闰 年 "); else System.out.println(a.getYear()+" 不 是 闰 年 "); 程 序 运 行 结 果 为 :

27 date is 不 是 闰 年 程 序 分 析 : 程 序 中 所 创 建 的 日 期 对 象, 其 成 员 变 量 都 有 一 个 初 值 当 对 象 创 建 后, 再 要 改 变 其 成 员 变 量 的 值, 可 用 setdate(int y, int m, int d) 方 法 进 行 修 改 getyear() getmonth() getday() 三 个 方 法 可 以 获 取 三 个 成 员 的 值 例 3.12 设 计 一 个 名 为 Fan 的 类 来 模 拟 风 扇, 属 性 为 speed on radius 和 color 假 设 风 扇 有 3 种 固 定 的 速 度, 用 常 数 表 示 慢 中 快 速 写 一 个 用 户 程 序, 程 序 中 创 建 一 个 Fan 对 象, 具 有 最 大 速 度 半 径 为 10 黄 色 打 开 状 态 这 4 个 属 性 值 要 求 返 回 包 含 类 中 所 有 属 性 值 的 字 符 串 分 析 : 这 个 问 题 已 经 给 了 类 名 和 属 性 名, 我 们 需 要 设 计 的 是 如 何 获 得 和 修 改 4 个 属 性 值, 以 及 如 何 将 4 个 属 性 转 换 为 字 符 串 // 文 件 名 Jpro3_12.java class Fan public static int SLOW=1; public static int MEDIUM=2; public static int FAST=3; private int speed; private boolean on; private double radius; private String color; public Fan() speed=slow; on=false; radius=5; color="white"; public int getspeed() return speed; public void setspeed(int newspeed) speed=newspeed; public boolean ison() return on; public void seton(boolean trueorfalse) on=trueorfalse; public double getradius() return radius; 第 3 章 类 与 对 象 63

28 64 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) public void setradius(double newradius) radius=newradius; public String getcolor() return color; public void setcolor(string newcolor) color=newcolor; public String tostring(int sp) String s=""; switch (sp) case 1:s="SLOW"; case 2:s="MEDIUM"; case 3:s="FAST"; return s; public class Jpro3_12 public static void main(string[] args) Fan ff=new Fan(); String s1,s2,s3,s4,s5,s6; ff.setspeed(3); s1=ff.tostring(ff.getspeed()); ff.setradius(10.0); s2=string.valueof(ff.getradius()); ff.setcolor("yellow"); s3=string.valueof(ff.getcolor()); ff.seton(true); s4=string.valueof(ff.ison()); System.out.println("The fan speed is:"+s1+" The fan radius is:"+s2); System.out.println("The fan color is:"+s3+" The fan status is:"+s4); 程 序 运 行 结 果 为 : The fan speed is:fast The fan radius is:10.0 The fan color is:yellow The fan status is:true 程 序 分 析 : 类 Fan 中 有 一 个 构 造 方 法, 用 来 初 始 化 4 个 成 员 变 量 类 中 的 其 他 方 法 :setspeed() setraidus() seton() 和 setcolor() 分 别 是 修 改 风 扇 的 速 度 半 径 当 前 状 态 和 颜 色 ;getspeed() getraidus() ison() 和 getcolor() 分 别 是 获 得 风 扇 的 当 前 速 度 半 径 状 态 和 颜 色 String 类 中

29 的 方 法 valueof() 可 以 将 不 同 的 数 据 类 型 转 换 为 字 符 串, 因 此 这 4 个 成 员 变 量 的 值 可 以 通 过 方 法 valueof() 转 换 成 字 符 串 我 们 希 望 速 度 也 能 以 定 义 的 常 量 标 识 符 表 示, 因 此 专 门 设 计 了 方 法 tostring() 用 于 实 现 速 度 的 转 换 习 题 三 1. 一 个 可 以 独 立 运 行 的 Java 应 用 程 序, A. 可 以 有 一 个 或 多 个 main() 方 法 B. 最 多 只 能 有 两 个 main() 方 法 C. 可 以 没 有 main() 方 法 D. 只 能 有 一 个 main() 方 法 2. 以 下 不 属 于 构 造 方 法 特 征 的 是 A. 构 造 方 法 名 与 其 类 名 相 同 B. 构 造 方 法 有 返 回 值 类 型 C. 构 造 方 法 在 创 建 对 象 时 自 动 执 行 D. 每 一 个 类 可 以 有 多 个 构 造 方 法 3. 下 列 哪 个 关 键 字 可 用 来 定 义 Java 常 量 A.public B.static C.final D.void 4.this 关 键 字 的 含 义 是 A. 本 类 B. 本 类 对 象 C. 这 个 类 D. 父 类 对 象 5. 下 列 关 于 Java 变 量 的 描 述, 错 误 的 是 A. 在 Java 程 序 中 要 使 用 变 量, 必 须 先 对 其 进 行 声 明 B. 类 变 量 可 以 使 用 对 象 名 进 行 调 用 C. 变 量 不 可 以 在 其 作 用 域 之 外 使 用 D. 成 员 变 量 必 须 写 在 成 员 方 法 之 前 6. 类 A 有 3 个 int 型 成 员 变 量 a b c, 则 是 类 A 的 正 确 构 造 方 法 A.void A()a=0; b=0; c=0; B.public void A() a=0; b=0; c=0; C.public int A (int x, int y, int z) a=x; b=y; c=z; D.public A(int x,int y, int z) a=x; b=y; c=z; 7. 指 出 下 列 程 序 中 的 非 法 语 句 class A int a; float b; a=12; b=12.56f; void f() 8. 假 设 A 类 定 义 如 下, 则 main() 方 法 中 哪 些 语 句 是 非 法 的? class A int x; private int y; 第 3 章 类 与 对 象 65

30 66 Java 面 向 对 象 程 序 设 计 ( 第 二 版 ) static String s; void methoda1() static void methoda2() public class Test A a=new A(); System.out.println(a.x); System.out.println(a.y); System.out.println(a.s); a.methoda1(); a.methoda2(); System.out.println(A.x); System.out.println(A.y); System.out.println(A.s); A.methodA1(); A.methodA2(); 9. 下 列 程 序 的 输 出 结 果 是 什 么? class A void f(int x,double y) x=x+1; y=y+1; System.out.printf(" 参 数 x 和 y 的 值 分 别 是 :%d,%f\n",x,y); public class Test int x=10; double y=12.58; A a=new A(); a.f(x,y); System.out.printf("main 方 法 中 x 和 y 的 值 仍 然 分 别 是 :%d,%f\n",x,y); 10. 写 一 个 名 为 Rectangle 的 类 表 示 矩 形 其 成 员 变 量 有 宽 width 高 height 颜 色 color, width 和 height 是 double 类 型,color 是 String 类 型 假 定 所 有 矩 形 颜 色 相 同, 用 一 个 类 变 量 表 示 颜 色 要 求 提 供 构 造 方 法 和 计 算 矩 形 面 积 的 computearea() 方 法 类 的 框 架 如 下, 只 给 出 方 法 名, 方 法 体 自 行 设 计 class Rectangle private double width=1; private double height=1;

31 private static String color= white ; public Rectangle() public Rectangle(double width,double height,string color) public double getwidth() public void setwidth(double width) public double getheight() public void setheight(double height) public static String getcolor() public static void setcolor(string color) public double computearea() 写 一 个 用 户 程 序 测 试 Rectangle 类 在 用 户 程 序 中, 创 建 两 个 Rectangle 对 象 对 两 个 对 象 设 置 任 意 的 宽 和 高 设 第 一 个 对 象 为 红 色, 第 二 个 为 黄 色 显 示 两 个 对 象 的 属 性 并 求 面 积 11. 设 计 一 个 日 期 类 及 其 测 试 类 ( 要 求 : 把 日 期 类 放 在 MyPackage 包 中, 测 试 类 和 日 期 类 不 在 同 一 包 中 ) 12. 定 义 一 个 图 书 类, 其 成 员 变 量 包 括 : 书 号 书 名 作 者, 单 价, 出 版 社 ; 定 义 带 参 构 造 方 法 初 始 化 成 员 变 量, 定 义 成 员 方 法 实 现 借 书 和 还 书 功 能 ; 另 外, 定 义 一 个 成 员 变 量 用 以 记 录 一 本 书 被 借 的 次 数 第 3 章 类 与 对 象 67