注 意 类 名 中 单 词 的 首 字 母 大 写 实 例 变 量 : 定 义 在 类 中 但 在 任 何 方 法 之 外 (New 出 来 的 均 有 初 值 ) 局 部 变 量 : 定 义 在 方 法 之 中 的 变 量 局 部 变 量 要 先 赋 值, 再 进 行 运 算, 而 实 例 变 量

Transcription

1 JAVA 的 面 向 对 象 编 程 课 堂 笔 记 面 向 对 象 主 要 针 对 面 向 过 程 面 向 过 程 的 基 本 单 元 是 函 数 什 么 是 对 象 :EVERYTHING IS OBJECT( 万 物 皆 对 象 ) 所 有 的 事 物 都 有 两 个 方 面 : 有 什 么 ( 属 性 ): 用 来 描 述 对 象 能 够 做 什 么 ( 方 法 ): 告 诉 外 界 对 象 有 那 些 功 能 后 者 以 前 者 为 基 础 大 的 对 象 的 属 性 也 可 以 是 一 个 对 象 为 什 么 要 使 用 面 向 对 象 : 首 先, 面 向 对 象 符 合 人 类 看 待 事 物 的 一 般 规 律 对 象 的 方 法 的 实 现 细 节 是 屏 蔽 的, 只 有 对 象 方 法 的 实 现 者 了 解 细 节 方 法 的 定 义 非 常 重 要 方 法 有 参 数, 也 可 能 有 返 回 值 注 意 区 分 : 对 象 ( 本 身 ) 对 象 的 实 现 者 对 象 的 调 用 者 分 析 对 象 主 要 从 方 法 开 始 我 们 通 过 类 来 看 待 对 象, 类 是 对 象 的 抽 象 其 次, 采 用 面 向 对 象 方 法 可 以 使 系 统 各 部 分 各 司 其 职 各 尽 所 能 对 象 之 间 的 耦 合 性 一 定 要 低 ( 比 如 不 同 硬 盘 和 不 同 主 板 之 间 的 关 系 ) 这 样 才 能 使 每 个 对 象 本 身 做 成 最 好 的 对 于 对 象 的 要 求 : 高 内 聚 低 耦 合, 这 样 容 易 拼 装 成 为 一 个 系 统 实 现 高 内 聚 就 是 要 最 大 限 度 低 提 高 复 用 性 ( 复 用 性 好 是 因 为 高 内 聚 ) 可 复 用 性 是 OOP 的 基 础 诚 信 创 新 开 放 合 作 比 较 面 向 过 程 的 思 想 和 面 向 对 象 的 思 想 : 面 向 过 程 的 思 想 : 由 过 程 步 骤 函 数 组 成, 以 过 程 为 核 心 ; 面 向 对 象 的 思 想 : 以 对 象 为 中 心, 先 开 发 类, 得 到 对 象, 通 过 对 象 之 间 相 互 通 信 实 现 功 能 面 向 过 程 是 先 有 算 法, 后 有 数 据 结 构 面 向 对 象 是 先 有 数 据 结 构, 然 后 再 有 算 法 在 用 面 向 对 象 思 想 开 发 的 过 程 中, 可 以 复 用 对 象 就 进 行 复 用, 如 无 法 进 行 复 用 则 开 发 新 的 对 象 开 发 过 程 是 用 对 个 简 单 的 对 象 的 多 个 简 单 的 方 法, 来 实 现 复 杂 的 功 能 从 语 法 上 来 看, 一 个 类 是 一 个 新 的 数 据 类 型 在 面 向 对 象 编 程 中, 除 了 简 单 数 据 类 型, 就 是 对 象 类 型 定 义 类 的 格 式 : class Student{ 代 码

2 注 意 类 名 中 单 词 的 首 字 母 大 写 实 例 变 量 : 定 义 在 类 中 但 在 任 何 方 法 之 外 (New 出 来 的 均 有 初 值 ) 局 部 变 量 : 定 义 在 方 法 之 中 的 变 量 局 部 变 量 要 先 赋 值, 再 进 行 运 算, 而 实 例 变 量 均 已 经 赋 初 值 这 是 局 部 变 量 和 实 例 变 量 的 一 大 区 别 实 例 变 量 的 对 象 赋 值 为 null 局 部 变 量 不 允 许 范 围 内 定 义 两 个 同 名 变 量 实 例 变 量 的 作 用 域 在 本 类 中 完 全 有 效, 当 被 其 他 的 类 调 用 的 时 候 也 可 能 有 效 实 例 变 量 和 局 部 变 量 允 许 命 名 冲 突 书 写 方 法 的 格 式 : 修 饰 符 返 回 值 方 法 名 调 用 过 程 中 方 法 体 可 能 出 现 的 例 外 public int/void addnumber( 参 数 ) throw Excepion { 例 : public int addnumber(int a,int b){ 注 : 方 法 名 中 的 参 数 int a,int b 为 局 部 变 量 类 方 法 中 的 一 类 特 殊 方 法 : 构 造 方 法 构 造 方 法 是 当 用 类 生 成 对 象 时, 系 统 在 生 成 对 象 的 过 程 中 利 用 的 方 法 注 意 : 构 造 方 法 在 生 成 对 象 的 时 候 会 被 调 用, 但 并 不 是 构 造 方 法 生 成 了 对 象 构 造 方 法 没 有 返 回 值 格 式 为 :public 方 法 名 构 造 方 法 的 方 法 名 与 类 名 相 同 构 造 方 法 是 在 对 象 生 成 的 过 程 中 自 动 调 用, 不 可 能 利 用 指 令 去 调 用 在 一 个 对 象 的 生 成 周 期 中 构 造 方 法 只 用 一 次, 一 旦 这 个 对 象 生 成, 那 么 这 个 构 造 方 法 失 效 用 类 来 生 成 对 象 的 语 句 : Student s=new Student() 第 一 个 Student 表 示 这 是 用 Student 类 进 行 定 义 Student() 表 示 调 用 一 个 无 参 数 的 构 造 方 法 如 果 () 中 有 参 数, 则 系 统 构 造 对 象 的 过 程 中 调 用 有 参 的 方 法 此 时 S 称 为 一 个 对 象 变 量 Student s 的 存 储 区 域 存 放 的 是 地 址 : 一 个 对 象 在 硬 盘 上 占 有 一 个 连 续 地 址, 首 地 址 赋 予 s 空 间 S 称 为 对 象 Student 的 引 用 注 意 : 在 对 象 变 量 中 存 放 的 是 引 用 ( 地 址 ); 在 简 单 变 量 中 存 放 的 是 数 值 可 以 构 造 多 个 构 造 方 法, 但 多 个 构 造 方 法 的 参 数 表 一 定 不 同, 参 数 顺 序 不 同 即 属 于 不 同 的 构 造 方 法 : public student(string name,int a){ public student(int a,string name){ 为 两 个 不 同 的 构 造 方 法 如 果 我 们 未 给 系 统 提 供 一 个 构 造 方 法, 那 么 系 统 会 自 动 提 供 一 个 为 空 的 构 造 方 法 练 习 : 写 一 个 类, 定 义 一 个 对 象, 定 义 两 个 构 造 方 法 : 一 个 有 参, 一 个 无 参 ( 编 写 一 个 程 序 验 证 对 象 的 传 递 的 值 为 地 址 ) 注 意 下 面 这 种 形 式 : static void changename(student stu){stu.setname LUCY

3 注 意 生 成 新 的 对 象 与 旧 对 象 指 向 无 关, 生 成 新 对 象 生 命 消 亡 与 旧 对 象 无 关 面 向 对 象 方 法 的 重 载 (overloading) 和 覆 盖 (overriding) 在 有 些 JAVA 书 籍 中 将 overriding 称 为 重 载,overloading 称 为 过 载 Overloading 在 一 个 类 中 可 以 定 义 多 个 同 名 方 法, 各 个 方 法 的 参 数 表 一 定 不 同 但 修 饰 词 可 能 相 同, 返 回 值 也 可 能 相 同 在 程 序 的 编 译 过 程 中 根 据 变 量 类 型 来 找 相 应 的 方 法 因 此 也 有 人 认 为 overloading 是 编 译 时 的 多 态, 以 后 我 们 还 会 学 到 运 行 时 多 态 为 什 么 会 存 在 overloading 技 术 呢? 作 为 应 对 方 法 的 细 节 利 用 类 型 的 差 异 来 影 响 对 方 法 的 调 用 吃 () 可 以 分 为 吃 肉, 吃 菜, 吃 药, 在 一 个 类 中 可 以 定 义 多 个 吃 方 法 构 造 方 法 也 可 以 实 现 overloading 例 : public void teach(){; public void teach(int a){; public void teach(string a){ 为 三 种 不 同 的 方 法 Overloading 方 法 是 从 低 向 高 转 Byte short float int long double 在 构 造 方 法 中,this 表 示 本 类 的 其 他 构 造 方 法 : student(){; student(string n){ this();// 表 示 调 用 student() 如 果 调 用 student(int a) 则 为 this(int a) 特 别 注 意 : 用 this 调 用 其 他 构 造 方 法 时,this 必 须 为 第 一 条 语 句, 然 后 才 是 其 他 语 句 This 表 示 当 前 对 象 Public void printnum(){ Int number=40; System.out.println(this.number); 此 时 打 印 的 是 实 例 变 量, 而 非 局 部 变 量, 即 定 义 在 类 中 而 非 方 法 中 的 变 量 This.number 表 示 实 例 变 量 谁 调 用 this.number 那 么 谁 即 为 当 前 (this) 对 象 的 number 方 法 封 装 : 使 对 象 的 属 性 尽 可 能 私 有, 对 象 的 方 法 尽 可 能 的 公 开 用 private 表 示 此 成 员 属 性 为 该 类 的 私 有 属 性 Public 表 示 该 属 性 ( 方 法 ) 公 开 ; Private 表 示 该 属 性 ( 方 法 ) 为 只 有 本 类 内 部 可 以 访 问 ( 类 内 部 可 见 ) ( 想 用 private 还 要 用 set 和 get 方 法 供 其 他 方 法 调 用, 这 样 可 以 保 证 对 属 性 的 访 问 方 式 统 一, 并 且 便 于 维 护 访 问 权 限 以 及 属 性 数 据 合 法 性 )

4 如 果 没 有 特 殊 情 况, 属 性 一 定 私 有, 方 法 该 公 开 的 公 开 如 果 不 指 明 谁 调 用 方 法, 则 默 认 为 this 区 分 实 例 变 量 和 局 部 变 量 时 一 定 要 写 this 继 承 : 父 类 (SuperClass) 和 子 类 (SonClass) 父 类 的 非 私 有 化 属 性 和 方 法 可 以 默 认 继 承 到 子 类 Class Son extends Father{ 而 如 果 父 类 中 的 私 有 方 法 被 子 类 调 用 的 话, 则 编 译 报 错 父 类 的 构 造 方 法 子 类 不 可 以 继 承, 更 不 存 在 覆 盖 的 问 题 ( 非 构 造 方 法 可 以 ) 如 果 子 类 访 问 父 类 的 构 造 方 法, 则 在 编 译 的 时 候 提 示 访 问 不 到 该 方 法 JAVA 中 不 允 许 多 继 承, 一 个 类 有 且 只 有 一 个 父 类 ( 单 继 承 ) JAVA 的 数 据 结 构 为 树 型 结 构, 而 非 网 状 (JAVA 通 过 接 口 和 内 部 类 实 现 多 继 承 ) 方 法 的 覆 盖 (overriding) 方 法 的 重 载 并 不 一 定 是 在 一 个 类 中 : 子 类 可 以 从 父 类 继 承 一 个 方 法, 也 可 以 定 义 一 个 同 名 异 参 的 方 法, 也 称 为 overloading 当 子 类 从 父 类 继 承 一 个 无 参 方 法, 而 又 定 义 了 一 个 同 样 的 无 参 方 法, 则 子 类 新 写 的 方 法 覆 盖 父 类 的 方 法, 称 为 覆 盖 ( 注 意 返 回 值 类 型 也 必 须 相 同, 否 则 编 译 出 错 ) 如 果 方 法 不 同, 则 成 重 载 对 于 方 法 的 修 饰 词, 子 类 方 法 要 比 父 类 的 方 法 范 围 更 加 的 宽 泛 父 类 为 public, 那 么 子 类 为 private 则 出 现 错 误 之 所 以 构 造 方 法 先 运 行 父 类 再 运 行 子 类 是 因 为 构 造 方 法 是 无 法 覆 盖 的 以 下 范 围 依 次 由 严 到 宽 : private : 本 类 访 问 ; default : 表 示 默 认, 不 仅 本 类 访 问, 而 且 是 同 包 可 见 Protected: 同 包 可 见 + 不 同 包 的 子 类 可 见 Public : 表 示 所 有 的 地 方 均 可 见 当 构 造 一 个 对 象 的 时 候, 系 统 先 构 造 父 类 对 象, 再 构 造 子 类 对 象 构 造 一 个 对 象 的 顺 序 :( 注 意 : 构 造 父 类 对 象 的 时 候 也 是 这 几 步 ) 1 递 归 地 构 造 父 类 对 象 ; 2 顺 序 地 调 用 本 类 成 员 属 性 赋 初 值 语 句 ; 3 本 类 的 构 造 方 法 Super() 表 示 调 用 父 类 的 构 造 方 法 Super() 也 和 this 一 样 必 须 放 在 第 一 行 This() 用 于 调 用 本 类 的 构 造 方 法 如 果 没 有 定 义 构 造 方 法, 那 么 就 会 调 用 父 类 的 无 参 构 造 方 法, 即 super() 要 养 成 良 好 的 编 程 习 惯 : 就 是 要 加 上 默 认 的 父 类 无 参 的 构 造 方 法 思 考 : 可 是 如 果 我 们 没 有 定 义 无 参 的 构 造 方 法, 而 在 程 序 中 构 造 了 有 参 的 构 造 方 法, 那 么 如 果 方 法 中 没 有 参 数, 那 么 系 统 还 会 调 用 有 参 的 构 造 方 法 么? 应 该 不 会

5 多 态 : 多 态 指 的 是 编 译 时 类 型 变 化, 而 运 行 时 类 型 不 变 多 态 分 两 种 : 1 编 译 时 多 态 : 编 译 时 动 态 重 载 ; 2 运 行 时 多 态 : 指 一 个 对 象 可 以 具 有 多 个 类 型 对 象 是 客 观 的, 人 对 对 象 的 认 识 是 主 观 的 例 : Animal a=new Dog(); 查 看 格 式 名 称 ; Dog d=(dog)a 声 明 父 类 来 引 用 子 类 ( 思 考 上 面 的 格 式 ) 运 行 时 多 态 的 三 原 则 :( 应 用 时 为 覆 盖 ) 1 对 象 不 变 ;( 改 变 的 是 主 观 认 识 ) 2 对 于 对 象 的 调 用 只 能 限 于 编 译 时 类 型 的 方 法, 如 调 用 运 行 时 类 型 方 法 报 错 在 上 面 的 例 子 中 :Animal a=new Dog(); 对 象 a 的 编 译 时 类 型 为 Animal, 运 行 时 类 型 为 dog 注 意 : 编 译 时 类 型 一 定 要 为 运 行 时 类 型 的 父 类 ( 或 者 同 类 型 ) 对 于 语 句 :Dog d=(dog)a 将 d 强 制 声 明 为 a 类 型, 此 时 d 为 Dog(), 此 时 d 就 可 以 调 用 运 行 时 类 型 注 意 :a 和 d 指 向 同 一 对 象 3 在 程 序 的 运 行 时, 动 态 类 型 判 定 运 行 时 调 用 运 行 时 类 型, 即 它 调 用 覆 盖 后 的 方 法 关 系 运 算 符 :instanceof a instanceof Animal;( 这 个 式 子 的 结 果 是 一 个 布 尔 表 达 式 ) a 为 对 象 变 量,Animal 是 类 名 上 面 语 句 是 判 定 a 是 否 可 以 贴 Animal 标 签 如 果 可 以 贴 则 返 回 true, 否 则 返 回 false 在 上 面 的 题 目 中 : a instanceof Animal 返 回 True, a instanceof Dog 也 返 回 True, instanceof 用 于 判 定 是 否 将 前 面 的 对 象 变 量 赋 值 后 边 的 类 名 Instanceof 一 般 用 于 在 强 制 类 型 转 换 之 前 判 定 变 量 是 否 可 以 强 制 转 换 如 果 Animal a=new Animal(); Dog d=dog()a; 此 时 编 译 无 误, 但 运 行 则 会 报 错 Animal a=new Dog() 相 当 于 下 面 语 句 的 功 能 : Animal a=getanimal(); Public static Animal.getAnimal; Return new Dog(); 封 装 继 承 多 态 为 面 向 对 象 的 三 大 基 石 ( 特 性 ) 运 行 时 的 动 态 类 型 判 定 针 对 的 是 方 法 运 行 程 序 访 问 的 属 性 仍 为 编 译 时 属 性 Overloading 针 对 的 是 编 译 时 类 型, 不 存 在 运 行 时 的 多 态 习 题 : 建 立 一 个 shape 类, 有 circle 和 rect 子 类 Shape 类 有 zhouchang() 和 area() 两 种 方 法

6 ( 正 方 形 )squ 为 rect 子 类,rect 有 cha() 用 于 比 较 长 宽 的 差 覆 盖 时 考 虑 子 类 的 private 及 父 类 的 public( 考 虑 多 态 ), 之 所 以 这 样 是 避 免 调 用 A 时 出 现 实 际 调 用 B 的 情 况 而 出 现 错 误 下 午 讲 的 是 教 程 上 的 Module6 Module6-7 包 括 : 面 向 对 象 高 级 内 部 类 集 合 反 射 ( 暂 时 不 讲 ) 例 外 面 向 对 象 高 级 集 合 和 例 外 都 是 面 向 对 象 的 核 心 内 容 面 向 对 象 高 级 : 修 饰 符 : static:1 可 修 饰 变 量 ( 属 性 );2 可 修 饰 方 法 ;3 可 修 饰 代 码 块 Static int data 语 句 说 明 data 为 类 变 量, 为 一 个 类 的 共 享 变 量, 属 于 整 个 类 Int data 为 实 例 变 量 例 : static int data; m1.data=0; m1.data++ 的 结 果 为 1, 此 时 m2.data 的 结 果 也 为 1 Static 定 义 的 是 一 块 为 整 个 类 共 有 的 一 块 存 储 区 域, 其 发 生 变 化 时 访 问 到 的 数 据 都 时 经 过 变 化 的 其 变 量 可 以 通 过 类 名 去 访 问 : 类 名. 变 量 名 与 通 过 访 问 对 象 的 编 译 时 类 型 访 问 类 变 量 为 等 价 的 Public static void printdata(){ 表 明 此 类 方 法 为 类 方 法 ( 静 态 方 法 ) 静 态 方 法 不 需 要 有 对 象, 可 以 使 用 类 名 调 用 静 态 方 法 中 不 允 许 访 问 类 的 非 静 态 成 员, 包 括 成 员 的 变 量 和 方 法, 因 为 此 时 是 通 过 类 调 用 的, 没 有 对 象 的 概 念 This.data 是 不 可 用 的 一 般 情 况 下, 主 方 法 是 静 态 方 法, 所 以 可 调 用 静 态 方 法, 主 方 法 为 静 态 方 法 是 因 为 它 是 整 个 软 件 系 统 的 入 口, 而 进 入 入 口 时 系 统 中 没 有 任 何 对 象, 只 能 使 用 类 调 用 覆 盖 不 适 用 于 静 态 方 法 静 态 方 法 不 可 被 覆 盖 ( 允 许 在 子 类 中 定 义 同 名 静 态 方 法, 但 是 没 有 多 态, 严 格 的 讲, 方 法 间 没 有 多 态 就 不 能 称 为 覆 盖 ) 当 static 修 饰 代 码 块 时 ( 注 : 此 代 码 块 要 在 此 类 的 任 何 一 个 方 法 之 外 ), 那 么 这 个 代 码 块 在 代 码 被 装 载 进 虚 拟 机 生 成 对 象 的 时 候 可 被 装 载 一 次, 以 后 再 也 不 执 行 了 一 般 静 态 代 码 块 被 用 来 初 始 化 静 态 成 员 Static 通 常 用 于 Singleton 模 式 开 发 : Singleton 是 一 种 设 计 模 式, 高 于 语 法, 可 以 保 证 一 个 类 在 整 个 系 统 中 仅 有 一 个 对 象 final 可 以 修 饰 类 属 性 方 法 当 用 final 修 饰 类 的 时 候, 此 类 不 可 被 继 承, 即 final 类 没 有 子 类 这 样 可 以 用 final 保 证 用 户 调 用 时 动 作 的 一 致 性, 可 以 防 止 子 类 覆 盖 情 况 的 发 生

7 当 利 用 final 修 饰 一 个 属 性 ( 变 量 ) 的 时 候, 此 时 的 属 性 成 为 常 量 JAVA 利 用 final 定 义 常 量 ( 注 意 在 JAVA 命 名 规 范 中 常 量 需 要 全 部 字 母 都 大 写 ): Final int AGE=10; 常 量 的 地 址 不 可 改 变, 但 在 地 址 中 保 存 的 值 ( 即 对 象 的 属 性 ) 是 可 以 改 变 的 Final 可 以 配 合 static 使 用? Static final int age=10; 在 JAVA 中 利 用 public static final 的 组 合 方 式 对 常 量 进 行 标 识 ( 固 定 格 式 ) 对 于 在 构 造 方 法 中 利 用 final 进 行 赋 值 的 时 候, 此 时 在 构 造 之 前 系 统 设 置 的 默 认 值 相 对 于 构 造 方 法 失 效 常 量 ( 这 里 的 常 量 指 的 是 实 例 常 量 : 即 成 员 变 量 ) 赋 值 : 1 在 初 始 化 的 时 候 通 过 显 式 声 明 赋 值 Final int x=3; 2 在 构 造 的 时 候 赋 值 局 部 变 量 可 以 随 时 赋 值 利 用 final 定 义 方 法 : 这 样 的 方 法 为 一 个 不 可 覆 盖 的 方 法 Public final void print(){; 为 了 保 证 方 法 的 一 致 性 ( 即 不 被 改 变 ), 可 将 方 法 用 final 定 义 如 果 在 父 类 中 有 final 定 义 的 方 法, 那 么 在 子 类 中 继 承 同 一 个 方 法 如 果 一 个 方 法 前 有 修 饰 词 private 或 static, 则 系 统 会 自 动 在 前 面 加 上 final 即 private 和 static 方 法 默 认 均 为 final 方 法 注 :final 并 不 涉 及 继 承, 继 承 取 决 于 类 的 修 饰 符 是 否 为 private default protected 还 是 public 也 就 是 说, 是 否 继 承 取 决 于 这 个 方 法 对 于 子 类 是 否 可 见 Abstract( 抽 象 ) 可 以 修 饰 类 方 法 如 果 将 一 个 类 设 置 为 abstract, 则 此 类 必 须 被 继 承 使 用 此 类 不 可 生 成 对 象, 必 须 被 继 承 使 用 Abstract 可 以 将 子 类 的 共 性 最 大 限 度 的 抽 取 出 来, 放 在 父 类 中, 以 提 高 程 序 的 简 洁 性 Abstract 虽 然 不 能 生 成 对 象, 但 是 可 以 声 明, 作 为 编 译 时 类 型, 但 不 能 作 为 运 行 时 类 型 Final 和 abstract 永 远 不 会 同 时 出 现 当 abstract 用 于 修 饰 方 法 时, 此 时 该 方 法 为 抽 象 方 法, 此 时 方 法 不 需 要 实 现, 实 现 留 给 子 类 覆 盖, 子 类 覆 盖 该 方 法 之 后 方 法 才 能 够 生 效 注 意 比 较 : private void print(){; 此 语 句 表 示 方 法 的 空 实 现 Abstract void print(); 此 语 句 表 示 方 法 的 抽 象, 无 实 现 如 果 一 个 类 中 有 一 个 抽 象 方 法, 那 么 这 个 类 一 定 为 一 个 抽 象 类 反 之, 如 果 一 个 类 为 抽 象 类, 那 么 其 中 可 能 有 非 抽 象 的 方 法 如 果 让 一 个 非 抽 象 类 继 承 一 个 含 抽 象 方 法 的 抽 象 类, 则 编 译 时 会 发 生 错 误 因 为 当 一 个 非 抽 象 类 继 承 一 个 抽 象 方 法 的 时 候, 本 着 只 有 一 个 类 中 有 一 个 抽 象 方 法, 那 么 这 个 类 必 须 为 抽 象 类 的 原 则 这 个 类 必 须

8 为 抽 象 类, 这 与 此 类 为 非 抽 象 冲 突, 所 以 报 错 所 以 子 类 的 方 法 必 须 覆 盖 父 类 的 抽 象 方 法 方 法 才 能 够 起 作 用 只 有 将 理 论 被 熟 练 运 用 在 实 际 的 程 序 设 计 的 过 程 中 之 后, 才 能 说 理 论 被 完 全 掌 握! 为 了 实 现 多 态, 那 么 父 类 必 须 有 定 义 而 父 类 并 不 实 现, 留 给 子 类 去 实 现 此 时 可 将 父 类 定 义 成 abstract 类 如 果 没 有 定 义 抽 象 的 父 类, 那 么 编 译 会 出 现 错 误 Abstract 和 static 不 能 放 在 一 起, 否 则 便 会 出 现 错 误 ( 这 是 因 为 static 不 可 被 覆 盖, 而 abstract 为 了 生 效 必 须 被 覆 盖 ) 例 :( 本 例 已 存 在 \CODING\abstract\TestClass.java 文 件 中 ) public class TestClass{ public static void main(string[] args){ SuperClass sc=new SubClass(); Sc.print(); Abstract class SuperClass{ Abstract void print(); class SubClass extends SuperClass(){ void print(){ System.out.println( print ); JAVA 的 核 心 概 念 : 接 口 (interface) 接 口 与 类 属 于 同 一 层 次, 实 际 上, 接 口 是 一 种 特 殊 的 抽 象 类 如 : interface IA{ public interface: 公 开 接 口 与 类 相 似, 一 个 文 件 只 能 有 一 个 public 接 口, 且 与 文 件 名 相 同 在 一 个 文 件 中 不 可 同 时 定 义 一 个 public 接 口 和 一 个 public 类 一 个 接 口 中, 所 有 方 法 为 公 开 抽 象 方 法 ; 所 有 的 属 性 都 是 公 开 静 态 常 量 一 个 类 实 现 一 个 接 口 的 格 式 : class IAImple implements IA{ ; 一 个 类 实 现 接 口, 相 当 于 它 继 承 一 个 抽 象 类 类 必 须 实 现 接 口 中 的 方 法, 否 则 其 为 一 抽 象 类 实 现 中 接 口 和 类 相 同 接 口 中 可 不 写 public, 但 在 子 类 中 实 现 接 口 的 过 程 中 public 不 可 省 ( 如 果 剩 去 public 则 在 编 译 的 时 候 提 示 出 错 : 对 象 无 法 从 接 口 中 实 现 方 法 )

9 注 : 1 一 个 类 除 继 承 另 外 一 个 类, 还 可 以 实 现 接 口 ; class IAImpl extends java.util.arrylist implement IA{ 继 承 类 实 现 接 口 这 样 可 以 实 现 变 相 的 多 继 承 2 一 个 类 只 能 继 承 另 外 一 个 类, 但 是 它 可 以 继 承 多 个 接 口, 中 间 用, 隔 开 Implements IA,IB 所 谓 实 现 一 个 接 口, 就 是 指 实 现 接 口 中 的 方 法 3 接 口 和 接 口 之 间 可 以 定 义 继 承 关 系, 并 且 接 口 之 间 允 许 实 现 多 继 承 例 :interface IC extends IA,IB{; 接 口 也 可 以 用 于 定 义 对 象 IA I=new IAImpl(); 实 现 的 类 从 父 类 和 接 口 继 承 的 都 可 做 运 行 时 类 型 IAImple extends A implement IA,IB IB I=new IAImple(); I instance of IAImple; I instance of A; I instance of IA; I instance of IB; 返 回 的 结 果 均 为 true. 接 口 和 多 态 都 为 JAVA 技 术 的 核 心 接 口 往 往 被 我 们 定 义 成 一 类 XX 的 东 西 接 口 实 际 上 是 定 义 一 个 规 范 标 准 1 通 过 接 口 可 以 实 现 不 同 层 次 不 同 体 系 对 象 的 共 同 属 性 ; 通 过 接 口 实 现 write once as anywhere. 以 JAVA 数 据 库 连 接 为 例 子 :JDBC 制 定 标 准 ; 数 据 厂 商 实 现 标 准 ; 用 户 使 用 标 准 接 口 通 常 用 来 屏 蔽 底 层 的 差 异 2 接 口 也 因 为 上 述 原 因 被 用 来 保 持 架 构 的 稳 定 性 JAVA 中 有 一 个 特 殊 的 类 : Object 它 是 JAVA 体 系 中 所 有 类 的 父 类 ( 直 接 父 类 或 者 间 接 父 类 ) 此 类 中 的 方 法 可 以 使 所 的 类 均 继 承 以 下 介 绍 的 三 种 方 法 属 于 Object: (1) finalize 方 法 : 当 一 个 对 象 被 垃 圾 回 收 的 时 候 调 用 的 方 法 (2) tostring(): 是 利 用 字 符 串 来 表 示 对 象 当 我 们 直 接 打 印 定 义 的 对 象 的 时 候, 隐 含 的 是 打 印 tostring() 的 返 回 值 可 以 通 过 子 类 作 为 一 个 tostring() 来 覆 盖 父 类 的 tostring() 以 取 得 我 们 想 得 到 的 表 现 形 式, 即 当 我 们 想 利 用 一 个 自 定 义 的 方 式 描 述 对 象 的 时 候, 我 们 应 该 覆 盖 tostring() (3)equal 首 先 试 比 较 下 例 : String A=new String( hello );

10 String A=new String( hello ); A==B( 此 时 程 序 返 回 为 FALSE) 因 为 此 时 AB 中 存 的 是 地 址, 因 为 创 建 了 新 的 对 象, 所 以 存 放 的 是 不 同 的 地 址 附 加 知 识 : 字 符 串 类 为 JAVA 中 的 特 殊 类,String 中 为 final 类, 一 个 字 符 串 的 值 不 可 重 复 因 此 在 JAVA VM( 虚 拟 机 ) 中 有 一 个 字 符 串 池, 专 门 用 来 存 储 字 符 串 如 果 遇 到 String a= hello 时 ( 注 意 没 有 NEW, 不 是 创 建 新 串 ), 系 统 在 字 符 串 池 中 寻 找 是 否 有 hello, 此 时 字 符 串 池 中 没 有 hello, 那 么 系 统 将 此 字 符 串 存 到 字 符 串 池 中, 然 后 将 hello 在 字 符 串 池 中 的 地 址 返 回 a 如 果 系 统 再 遇 到 String b= hello, 此 时 系 统 可 以 在 字 符 串 池 中 找 到 hello 则 会 把 地 址 返 回 b, 此 时 a 与 b 为 相 同 String a= hello ; System.out.println(a== hello ); 系 统 的 返 回 值 为 true 故 如 果 要 比 较 两 个 字 符 串 是 否 相 同 ( 而 不 是 他 们 的 地 址 是 否 相 同 ) 可 以 对 a 调 用 equal: System.out.println(a.equal(b)); equal 用 来 比 较 两 个 对 象 中 字 符 串 的 顺 序 a.equal(b) 是 a 与 b 的 值 的 比 较 注 意 下 面 程 序 : student a=new student( LUCY,20); student b=new student( LUCY,20); System.out.println(a==b); System.out.println(a.equal(b)); 此 时 返 回 的 结 果 均 为 false 以 下 为 定 义 equal( 加 上 这 个 定 义, 返 回 ture 或 false) public boolean equals(object o){ student s=(student)o; if (s.name.equals(this.name)&&s.age==this.age) else return false; 如 果 equals() 返 回 的 值 为 以 下 为 实 现 标 准 equals 的 流 程 : public boolean equals(object o){ if (this==o) return trun; // 此 时 两 者 相 同 if (o==null) return false; if (! o instanceof strudent) return false; // 不 同 类 studeng s=(student)o; // 强 制 转 换 if (s.name.equals(this.name)&&s.age==this.age) return true; else return false; 以 上 过 程 为 实 现 equals 的 标 准 过 程

11 练 习 : 建 立 一 个 employee 类, 有 String name,int id,double salary. 运 用 get 和 set 方 法, 使 用 tostring, 使 用 equals 封 装 类 : JAVA 为 每 一 个 简 单 数 据 类 型 提 供 了 一 个 封 装 类, 使 每 个 简 单 数 据 类 型 可 以 被 Object 来 装 载 除 了 int 和 char, 其 余 类 型 首 字 母 大 写 即 成 封 装 类 转 换 字 符 的 方 式 : int I=10; String s=i+ ; String s1=string.valueof(i); Int I=10; Interger I_class=new integer(i); 看 javadoc 的 帮 助 文 档 附 加 内 容 : == 在 任 何 时 候 都 是 比 较 地 址, 这 种 比 较 永 远 不 会 被 覆 盖 程 序 员 自 己 编 写 的 类 和 JDK 类 是 一 种 合 作 关 系 ( 因 为 多 态 的 存 在, 可 能 存 在 我 们 调 用 JDK 类 的 情 况, 也 可 能 存 在 JDK 自 动 调 用 我 们 的 类 的 情 况 ) 注 意 : 类 型 转 换 中 double\interger\string 之 间 的 转 换 最 多 内 部 类 : ( 注 : 所 有 使 用 内 部 类 的 地 方 都 可 以 不 用 内 部 类, 使 用 内 部 类 可 以 使 程 序 更 加 的 简 洁, 便 于 命 名 规 范 和 划 分 层 次 结 构 ) 内 部 类 是 指 在 一 个 外 部 类 的 内 部 再 定 义 一 个 类 内 部 类 作 为 外 部 类 的 一 个 成 员, 并 且 依 附 于 外 部 类 而 存 在 的 内 部 类 可 为 静 态, 可 用 PROTECTED 和 PRIVATE 修 饰 ( 而 外 部 类 不 可 以 : 外 部 类 只 能 使 用 PUBLIC 和 DEFAULT) 内 部 类 的 分 类 : 成 员 内 部 类 局 部 内 部 类 静 态 内 部 类 匿 名 内 部 类 ( 图 形 是 要 用 到, 必 须 掌 握 ) 1 成 员 内 部 类 : 作 为 外 部 类 的 一 个 成 员 存 在, 与 外 部 类 的 属 性 方 法 并 列 内 部 类 和 外 部 类 的 实 例 变 量 可 以 共 存 在 内 部 类 中 访 问 实 例 变 量 :this. 属 性 在 内 部 类 访 问 外 部 类 的 实 例 变 量 : 外 部 类 名.this. 属 性 成 员 内 部 类 的 优 点 : ⑴ 内 部 类 作 为 外 部 类 的 成 员, 可 以 访 问 外 部 类 的 私 有 成 员 或 属 性 ( 即 使 将 外 部 类 声 明 为 PRIVATE, 但 是 对 于 处 于 其 内 部 的 内 部 类 还 是 可 见 的 )

12 ⑵ 用 内 部 类 定 义 在 外 部 类 中 不 可 访 问 的 属 性 这 样 就 在 外 部 类 中 实 现 了 比 外 部 类 的 private 还 要 小 的 访 问 权 限 注 意 : 内 部 类 是 一 个 编 译 时 的 概 念, 一 旦 编 译 成 功, 就 会 成 为 完 全 不 同 的 两 类 对 于 一 个 名 为 outer 的 外 部 类 和 其 内 部 定 义 的 名 为 inner 的 内 部 类 编 译 完 成 后 出 现 outer.class 和 outer$inner.class 两 类 ( 编 写 一 个 程 序 检 验 : 在 一 个 TestOuter.java 程 序 中 验 证 内 部 类 在 编 译 完 成 之 后, 会 出 现 几 个 class.) 成 员 内 部 类 不 可 以 有 静 态 属 性 ( 为 什 么?) 如 果 在 外 部 类 的 外 部 访 问 内 部 类, 使 用 out.inner. 建 立 内 部 类 对 象 时 应 注 意 : 在 外 部 类 的 内 部 可 以 直 接 使 用 inner s=new inner();( 因 为 外 部 类 知 道 inner 是 哪 个 类, 所 以 可 以 生 成 对 象 ) 而 在 外 部 类 的 外 部, 要 生 成 (new) 一 个 内 部 类 对 象, 需 要 首 先 建 立 一 个 外 部 类 对 象 ( 外 部 类 可 用 ), 然 后 在 生 成 一 个 内 部 类 对 象 Outer.Inner in=outer.new.inner() 错 误 的 定 义 方 式 : Outer.Inner in=new Outer.Inner() 注 意 : 当 Outer 是 一 个 private 类 时, 外 部 类 对 于 其 外 部 访 问 是 私 有 的, 所 以 就 无 法 建 立 外 部 类 对 象, 进 而 也 无 法 建 立 内 部 类 对 象 2 局 部 内 部 类 : 在 方 法 中 定 义 的 内 部 类 称 为 局 部 内 部 类 与 局 部 变 量 类 似, 在 局 部 内 部 类 前 不 加 修 饰 符 public 和 private, 其 范 围 为 定 义 它 的 代 码 块 注 意 : 局 部 内 部 类 不 仅 可 以 访 问 外 部 类 实 例 变 量, 还 可 以 访 问 外 部 类 的 局 部 变 量 ( 但 此 时 要 求 外 部 类 的 局 部 变 量 必 须 为 final)?? 在 类 外 不 可 直 接 生 成 局 部 内 部 类 ( 保 证 局 部 内 部 类 对 外 是 不 可 见 的 ) 要 想 使 用 局 部 内 部 类 时 需 要 生 成 对 象, 对 象 调 用 方 法, 在 方 法 中 才 能 调 用 其 局 部 内 部 类 3 静 态 内 部 类 :( 注 意 : 前 三 种 内 部 类 与 变 量 类 似, 所 以 可 以 对 照 参 考 变 量 ) 静 态 内 部 类 定 义 在 类 中, 任 何 方 法 外, 用 static 定 义 静 态 内 部 类 只 能 访 问 外 部 类 的 静 态 成 员 生 成 (new) 一 个 静 态 内 部 类 不 需 要 外 部 类 成 员 : 这 是 静 态 内 部 类 和 成 员 内 部 类 的 区 别 静 态 内 部 类 的 对 象 可 以 直 接 生 成 : Outer.Inner in=new Outer.Inner(); 而 不 需 要 通 过 生 成 外 部 类 对 象 来 生 成 这 样 实 际 上 使 静 态 内 部 类 成 为 了 一 个 顶 级 类 静 态 内 部 类 不 可 用 private 来 进 行 定 义 例 子 : 对 于 两 个 类, 拥 有 相 同 的 方 法 : People { run(); Machine{ run();

13 此 时 有 一 个 robot 类 : class Robot extends People implement Machine. 此 时 run() 不 可 直 接 实 现 注 意 : 当 类 与 接 口 ( 或 者 是 接 口 与 接 口 ) 发 生 方 法 命 名 冲 突 的 时 候, 此 时 必 须 使 用 内 部 类 来 实 现 用 接 口 不 能 完 全 地 实 现 多 继 承, 用 接 口 配 合 内 部 类 才 能 实 现 真 正 的 多 继 承 4 匿 名 内 部 类 ( 必 须 掌 握 ): 匿 名 内 部 类 是 一 种 特 殊 的 局 部 内 部 类, 它 是 通 过 匿 名 类 实 现 接 口 IA 被 定 义 为 接 口 IA I=new IA(){; 注 : 一 个 匿 名 内 部 类 一 定 是 在 new 的 后 面, 用 其 隐 含 实 现 一 个 接 口 或 实 现 一 个 类, 没 有 类 名, 根 据 多 态, 我 们 使 用 其 父 类 名 因 其 为 局 部 内 部 类, 那 么 局 部 内 部 类 的 所 有 限 制 都 对 其 生 效 匿 名 内 部 类 是 唯 一 一 种 无 构 造 方 法 类 匿 名 内 部 类 在 编 译 的 时 候 由 系 统 自 动 起 名 Out$1.class 如 果 一 个 对 象 编 译 时 的 类 型 是 接 口, 那 么 其 运 行 的 类 型 为 实 现 这 个 接 口 的 类 因 匿 名 内 部 类 无 构 造 方 法, 所 以 其 使 用 范 围 非 常 的 有 限 ( 下 午 :)Exception( 例 外 / 异 常 )( 教 程 上 的 MODEL7) 对 于 程 序 可 能 出 现 的 错 误 应 该 做 出 预 案 例 外 是 程 序 中 所 有 出 乎 意 料 的 结 果 ( 关 系 到 系 统 的 健 壮 性 ) JAVA 会 将 所 有 的 错 误 封 装 成 为 一 个 对 象, 其 根 本 父 类 为 Throwable Throwable 有 两 个 子 类 :Error 和 Exception 一 个 Error 对 象 表 示 一 个 程 序 错 误, 指 的 是 底 层 的 低 级 的 不 可 恢 复 的 严 重 错 误 此 时 程 序 一 定 会 退 出, 因 为 已 经 失 去 了 运 行 所 必 须 的 物 理 环 境 对 于 Error 错 误 我 们 无 法 进 行 处 理, 因 为 我 们 是 通 过 程 序 来 应 对 错 误, 可 是 程 序 已 经 退 出 了 我 们 可 以 处 理 的 Throwable 对 象 中 只 有 Exception 对 象 ( 例 外 / 异 常 ) Exception 有 两 个 子 类 :Runtime exception( 未 检 查 异 常 ) 非 Runtime exception( 已 检 查 异 常 ) ( 注 意 : 无 论 是 未 检 查 异 常 还 是 已 检 查 异 常 在 编 译 的 时 候 都 不 会 被 发 现, 在 编 译 的 过 程 中 检 查 的 是 程 序 的 语 法 错 误, 而 异 常 是 一 个 运 行 时 程 序 出 错 的 概 念 ) 在 Exception 中, 所 有 的 非 未 检 查 异 常 都 是 已 检 查 异 常, 没 有 另 外 的 异 常!! 未 检 查 异 常 是 因 为 程 序 员 没 有 进 行 必 要 的 检 查, 因 为 他 的 疏 忽 和 错 误 而 引 起 的 异 常 一 定 是 属 于 虚 拟 机 内 部 的 异 常 ( 比 如 空 指 针 ) 应 对 未 检 查 异 常 就 是 养 成 良 好 的 检 查 习 惯 已 检 查 异 常 是 不 可 避 免 的, 对 于 已 检 查 异 常 必 须 实 现 定 义 好 应 对 的 方 法 已 检 查 异 常 肯 定 跨 越 出 了 虚 拟 机 的 范 围 ( 比 如 未 找 到 文 件 ) 如 何 处 理 已 检 查 异 常 ( 对 于 所 有 的 已 检 查 异 常 都 要 进 行 处 理 ): 首 先 了 解 异 常 形 成 的 机 制 : 当 一 个 方 法 中 有 一 条 语 句 出 现 了 异 常, 它 就 会 throw( 抛 出 ) 一 个 例 外 对 象, 然 后 后 面 的 语 句 不 会 执 行 返 回 上 一 级 方 法, 其 上 一 级 方 法 接 受 到 了 例 外 对 象 之 后, 有 可 能 对 这 个 异 常 进 行 处 理, 也 可 能 将 这 个 异 常 转 到 它 的 上 一 级 对 于 接 收 到 的 已 检 查 异 常 有 两 种 处 理 方 式 :throws 和 try 方 法

14 注 意 : 出 错 的 方 法 有 可 能 是 JDK, 也 可 能 是 程 序 员 写 的 程 序, 无 论 谁 写 的, 抛 出 一 定 用 throw 例 :public void print() throws Exception. 对 于 方 法 a, 如 果 它 定 义 了 throws Exception 那 么 当 它 调 用 的 方 法 b 返 回 异 常 对 象 时, 方 法 a 并 不 处 理, 而 将 这 个 异 常 对 象 向 上 一 级 返 回, 如 果 所 有 的 方 法 均 不 进 行 处 理, 返 回 到 主 方 法, 程 序 中 止 ( 要 避 免 所 有 的 方 法 都 返 回 的 使 用 方 法, 因 为 这 样 出 现 一 个 很 小 的 异 常 就 会 令 程 序 中 止 ) 如 果 在 方 法 的 程 序 中 有 一 行 throw new Exception(), 返 回 错 误, 那 么 其 后 的 程 序 不 执 行 因 为 错 误 返 回 后, 后 面 的 程 序 肯 定 没 有 机 会 执 行, 那 么 JAVA 认 为 以 后 的 程 序 没 有 存 在 的 必 要 对 于 try catch 格 式 : try { 可 能 出 现 错 误 的 代 码 块 catch(exception e){ 进 行 处 理 的 代 码 ; 对 象 变 量 的 声 明 用 这 种 方 法, 如 果 代 码 正 确, 那 么 程 序 不 经 过 catch 语 句 直 接 向 下 运 行 ; 如 果 代 码 不 正 确, 则 将 返 回 的 异 常 对 象 和 e 进 行 匹 配, 如 果 匹 配 成 功, 则 处 理 其 后 面 的 异 常 处 理 代 码 ( 如 果 用 exception 来 声 明 e 的 话, 因 为 exception 为 所 有 exception 对 象 的 父 类, 所 有 肯 定 匹 配 成 功 ) 处 理 完 代 码 后 这 个 例 外 就 完 全 处 理 完 毕, 程 序 会 接 着 从 出 现 异 常 的 地 方 向 下 执 行 ( 是 从 出 现 异 常 的 地 方 还 是 在 catch 后 面 呢? 利 用 程 序 进 行 验 证 ) 最 后 程 序 正 常 退 出 Try 中 如 果 发 现 错 误, 即 跳 出 try 去 匹 配 catch, 那 么 try 后 面 的 语 句 就 不 会 被 执 行 一 个 try 可 以 跟 进 多 个 catch 语 句, 用 于 处 理 不 同 情 况 当 一 个 try 只 能 匹 配 一 个 catch 我 们 可 以 写 多 个 catch 语 句, 但 是 不 能 将 父 类 型 的 exception 的 位 置 写 在 子 类 型 的 excepiton 之 前, 因 为 这 样 父 类 型 肯 定 先 于 子 类 型 被 匹 配, 所 有 子 类 型 就 成 为 废 话 JAVA 编 译 出 错 在 try,catch 后 还 可 以 再 跟 一 子 句 finally 其 中 的 代 码 语 句 无 论 如 何 都 会 被 执 行 ( 因 为 finally 子 句 的 这 个 特 性, 所 以 一 般 将 释 放 资 源, 关 闭 连 接 的 语 句 写 在 里 面 ) 如 果 在 程 序 中 书 写 了 检 查 ( 抛 出 )exception 但 是 没 有 对 这 个 可 能 出 现 的 检 查 结 果 进 行 处 理, 那 么 程 序 就 会 报 错 而 如 果 只 有 处 理 情 况 (try) 而 没 有 相 应 的 catch 子 句, 则 编 译 还 是 通 不 过 如 何 知 道 在 编 写 的 程 序 中 会 出 现 例 外 呢 1. 调 用 方 法, 查 看 API 中 查 看 方 法 中 是 否 有 已 检 查 错 误 2. 在 编 译 的 过 程 中 看 提 示 信 息, 然 后 加 上 相 应 的 处 理 Exception 有 一 个 message 属 性 在 使 用 catch 的 时 候 可 以 调 用 : Catch(IOException e){system.out.println(e.message()); Catch(IOException e){e.printstacktrace(); 上 面 这 条 语 句 回 告 诉 我 们 出 错 类 型 所 历 经 的 过 程, 在 调 试 的 中 非 常 有 用 开 发 中 的 两 个 道 理 : 1 如 何 控 制 try 的 范 围 : 根 据 操 作 的 连 动 性 和 相 关 性, 如 果 前 面 的 程 序 代 码 块 抛 出 的 错 误 影 响 了 后 面 程 序 代 码 的 运 行, 那 么 这 个 我 们 就 说 这 两 个 程 序 代 码 存 在 关 联, 应 该 放 在 同 一 个 try 中 2 对 已 经 查 出 来 的 例 外, 有 throw( 积 极 ) 和 try catch( 消 极 ) 两 种 处 理 方 法 对 于 try catch 放 在 能 够 很 好 地 处 理 例 外 的 位 置 ( 即 放 在 具 备 对 例 外 进 行 处 理 的 能 力 的 位 置 ) 如 果 没

15 有 处 理 能 力 就 继 续 上 抛 当 我 们 自 己 定 义 一 个 例 外 类 的 时 候 必 须 使 其 继 承 excepiton 或 者 RuntimeException Throw 是 一 个 语 句, 用 来 做 抛 出 例 外 的 功 能 而 throws 是 表 示 如 果 下 级 方 法 中 如 果 有 例 外 抛 出, 那 么 本 方 法 不 做 处 理, 继 续 向 上 抛 出 Throws 后 跟 的 是 例 外 类 型 断 言 是 一 种 调 试 工 具 (assert) 其 后 跟 的 是 布 尔 类 型 的 表 达 式, 如 果 表 达 式 结 果 为 真 不 影 响 程 序 运 行 如 果 为 假 系 统 出 现 低 级 错 误, 在 屏 幕 上 出 现 assert 信 息 Assert 只 是 用 于 调 试 在 产 品 编 译 完 成 后 上 线 assert 代 码 就 被 删 除 了 方 法 的 覆 盖 中, 如 果 子 类 的 方 法 抛 出 的 例 外 是 父 类 方 法 抛 出 的 例 外 的 父 类 型, 那 么 编 译 就 会 出 错 : 子 类 无 法 覆 盖 父 类 结 论 : 子 类 方 法 不 可 比 父 类 方 法 抛 出 更 多 的 例 外 子 类 抛 出 的 例 外 或 者 与 父 类 抛 出 的 例 外 一 致, 或 者 是 父 类 抛 出 例 外 的 子 类 型 或 者 子 类 型 不 抛 出 例 外 如 果 父 类 型 无 throws 时, 子 类 型 也 不 允 许 出 现 throws 此 时 只 能 使 用 try catch 练 习 : 写 一 个 方 法 :int add(int a,int b) { return a+b; 当 a+b=100; 抛 出 100 为 异 常 处 理 集 合 ( 从 本 部 分 开 始 涉 及 API) 集 合 是 指 一 个 对 象 容 纳 了 多 个 对 象, 这 个 集 合 对 象 主 要 用 来 管 理 维 护 一 系 列 相 似 的 对 象 数 组 就 是 一 种 对 象 ( 练 习 : 如 何 编 写 一 个 数 组 程 序, 并 进 行 遍 历 ) java.util.* 定 义 了 一 系 列 的 接 口 和 类, 告 诉 我 们 用 什 么 类 NEW 出 一 个 对 象, 可 以 进 行 超 越 数 组 的 操 作 ( 注 :JAVA1.5 对 JAVA1.4 的 最 大 改 进 就 是 增 加 了 对 范 型 的 支 持 ) 集 合 框 架 接 口 的 分 类 :( 分 collection 接 口 和 map 接 口 ) Collection 接 口 Map 接 口 List 接 口 Set 接 口 SortedMap 接 口 SortedSet 接 口 JAVA 中 所 有 与 集 合 有 关 的 实 现 类 都 是 这 六 个 接 口 的 实 现 类 Collection 接 口 : 集 合 中 每 一 个 元 素 为 一 个 对 象, 这 个 接 口 将 这 些 对 象 组 织 在 一 起, 形 成 一 维 结 构 List 接 口 代 表 按 照 元 素 一 定 的 相 关 顺 序 来 组 织 ( 在 这 个 序 列 中 顺 序 是 主 要 的 ),List 接 口 中 数 据 可 重 复 Set 接 口 是 数 学 中 集 合 的 概 念 : 其 元 素 无 序, 且 不 可 重 复 ( 正 好 与 List 对 应 ) SortedSet 会 按 照 数 字 将 元 素 排 列, 为 可 排 序 集 合

16 Map 接 口 中 每 一 个 元 素 不 是 一 个 对 象, 而 是 一 个 键 对 象 和 值 对 象 组 成 的 键 值 对 (Key-Value) Key-Value 是 用 一 个 不 可 重 复 的 key 集 合 对 应 可 重 复 的 value 集 合 ( 典 型 的 例 子 是 字 典 : 通 过 页 码 的 key 值 找 字 的 value 值 ) 例 子 : key1 value1; key2 value2; key3 value3. SortedMap: 如 果 一 个 Map 可 以 根 据 key 值 排 序, 则 称 其 为 SortedMap ( 如 字 典 )!! 注 意 数 组 和 集 合 的 区 别 : 数 组 中 只 能 存 简 单 数 据 类 型 Collection 接 口 和 Map 接 口 只 能 存 对 象 以 下 介 绍 接 口 : List 接 口 :( 介 绍 其 下 的 两 个 实 现 类 :ArrayList 和 LinkedList) ArrayList 和 数 组 非 常 类 似, 其 底 层 1 也 用 数 组 组 织 数 据,ArrayList 是 动 态 可 变 数 组 1 底 层 : 指 存 储 格 式 说 明 ArrayList 对 象 都 是 存 在 于 数 组 中 注 : 数 组 和 集 合 都 是 从 下 标 0 开 始 ArrayList 有 一 个 add(object o) 方 法 用 于 插 入 数 组 ArrayList 的 使 用 :( 完 成 这 个 程 序 ) 先 import java.util.*; 用 ArrayList 在 一 个 数 组 中 添 加 数 据, 并 遍 历 ArrayList 中 数 组 的 顺 序 与 添 加 顺 序 一 致 只 有 List 可 用 get 和 size 而 Set 则 不 可 用 ( 因 其 无 序 ) Collection 接 口 都 是 通 过 Iterator()( 即 迭 代 器 ) 来 对 Set 和 List 遍 历 通 过 语 句 :Iterator it=c.iterator(); 得 到 一 个 迭 代 器, 将 集 合 中 所 有 元 素 顺 序 排 列 然 后 可 以 通 过 interator 方 法 进 行 遍 历, 迭 代 器 有 一 个 游 标 ( 指 针 ) 指 向 首 位 置 Interator 有 hasnext(), 用 于 判 断 元 素 右 边 是 否 还 有 数 据, 返 回 True 说 明 有 然 后 就 可 以 调 用 next 动 作 Next() 会 将 游 标 移 到 下 一 个 元 素, 并 把 它 所 跨 过 的 元 素 返 回 ( 这 样 就 可 以 对 元 素 进 行 遍 历 ) 练 习 : 写 一 个 程 序, 输 入 对 象 信 息, 比 较 基 本 信 息 集 合 中 每 一 个 元 素 都 有 对 象, 如 有 字 符 串 要 经 过 强 制 类 型 转 换 Collections 是 工 具 类, 所 有 方 法 均 为 有 用 方 法, 且 方 法 为 static 有 Sort 方 法 用 于 给 List 排 序 Collections.Sort() 分 为 两 部 分, 一 部 分 为 排 序 规 则 ; 一 部 分 为 排 序 算 法 规 则 用 来 判 断 对 象 ; 算 法 是 考 虑 如 何 排 序 对 于 自 定 义 对 象,Sort 不 知 道 规 则, 所 以 无 法 比 较 这 种 情 况 下 一 定 要 定 义 排 序 规 则 方 式 有 两 种 : 1 java.lang 下 面 有 一 个 接 口 :Comparable( 可 比 较 的 ) 可 以 让 自 定 义 对 象 实 现 一 个 接 口, 这 个 接 口 只 有 一 个 方 法 comparableto(object o) 其 规 则 是 当 前 对 象 与 o 对 象 进 行 比 较, 其 返 回 一 个 int 值, 系 统 根 据 此 值 来 进 行 排 序 如 当 前 对 象 >o 对 象, 则 返 回 值 >0;( 可 将 返 回 值 定 义 为 1) 如 当 前 对 象 =o 对 象, 则 返 回 值 =0; 如 当 前 对 象 <o 对 象, 则 返 回 值 0 ( 可 将 返 回 值 定 义 为 -1) 看 TestArraylist 的 java 代 码 我 们 通 过 返 回 值 1 和 -1 位 置 的 调 换 来 实 现 升 序 和 降 序 排 列 的 转 换 2 java.util 下 有 一 个 Comparator( 比 较 器 ) 它 拥 有 compare(), 用 来 比 较 两 个 方 法 要 生 成 比 较 器, 则 用 Sort 中 Sort(List,List(Compate)) 第 二 种 方 法 更 灵 活, 且 在 运 行 的 时 候 不 用 编 译

17 注 意 : 要 想 实 现 comparto() 就 必 须 在 主 方 法 中 写 上 implement comparable. 练 习 : 生 成 一 个 EMPLOYEE 类, 然 后 将 一 系 列 对 象 放 入 到 ArrayList 用 Iterator 遍 历, 排 序 之 后, 再 进 行 遍 历 集 合 的 最 大 缺 点 是 无 法 进 行 类 型 判 定 ( 这 个 缺 点 在 JAVA1.5 中 已 经 解 决 ), 这 样 就 可 能 出 现 因 为 类 型 不 同 而 出 现 类 型 错 误 解 决 的 方 法 是 添 加 类 型 的 判 断 LinkedList 接 口 ( 在 代 码 的 使 用 过 程 中 和 ArrayList 没 有 什 么 区 别 ) ArrayList 底 层 是 object 数 组, 所 以 ArrayList 具 有 数 组 的 查 询 速 度 快 的 优 点 以 及 增 删 速 度 慢 的 缺 点 而 在 LinkedList 的 底 层 是 一 种 双 向 循 环 链 表 在 此 链 表 上 每 一 个 数 据 节 点 都 由 三 部 分 组 成 : 前 指 针 ( 指 向 前 面 的 节 点 的 位 置 ), 数 据, 后 指 针 ( 指 向 后 面 的 节 点 的 位 置 ) 最 后 一 个 节 点 的 后 指 针 指 向 第 一 个 节 点 的 前 指 针, 形 成 一 个 循 环 双 向 循 环 链 表 的 查 询 效 率 低 但 是 增 删 效 率 高 所 以 LinkedList 具 有 查 询 效 率 低 但 增 删 效 率 高 的 特 点 ArrayList 和 LinkedList 在 用 法 上 没 有 区 别, 但 是 在 功 能 上 还 是 有 区 别 的 LinkedList 经 常 用 在 增 删 操 作 较 多 而 查 询 操 作 很 少 的 情 况 下 : 队 列 和 堆 栈 队 列 : 先 进 先 出 的 数 据 结 构 堆 栈 : 后 进 先 出 的 数 据 结 构 注 意 : 使 用 堆 栈 的 时 候 一 定 不 能 提 供 方 法 让 不 是 最 后 一 个 元 素 的 元 素 获 得 出 栈 的 机 会 LinkedList 提 供 以 下 方 法 :(ArrayList 无 此 类 方 法 ) addfirst(); removefirst(); addlast(); removelast(); 在 堆 栈 中,push 为 入 栈 操 作,pop 为 出 栈 操 作 Push 用 addfirst();pop 用 removefirst(), 实 现 后 进 先 出 用 isempty()-- 其 父 类 的 方 法, 来 判 断 栈 是 否 为 空 在 队 列 中,put 为 入 队 列 操 作,get 为 出 队 列 操 作 Put 用 addfirst(),get 用 removelast() 实 现 队 列 List 接 口 的 实 现 类 (Vector)( 与 ArrayList 相 似, 区 别 是 Vector 是 重 量 级 的 组 件, 使 用 使 消 耗 的 资 源 比 较 多 ) 结 论 : 在 考 虑 并 发 的 情 况 下 用 Vector( 保 证 线 程 的 安 全 ) 在 不 考 虑 并 发 的 情 况 下 用 ArrayList( 不 能 保 证 线 程 的 安 全 ) 面 试 经 验 ( 知 识 点 ): java.util.stack(stack 即 为 堆 栈 ) 的 父 类 为 Vector 可 是 stack 的 父 类 是 最 不 应 该 为 Vector 的 因 为 Vector 的 底 层 是 数 组, 且 Vector 有 get 方 法 ( 意 味 着 它 可 能 访 问 到 并 不 属 于 最 后 一 个 位 置 元 素 的 其 他 元 素, 很 不 安 全 ) 对 于 堆 栈 和 队 列 只 能 用 push 类 和 get 类 Stack 类 以 后 不 要 轻 易 使 用!!! 实 现 堆 栈 一 定 要 用 LinkedList ( 在 JAVA1.5 中,collection 有 queue 来 实 现 队 列 )

18 Set-HashSet 实 现 类 : 遍 历 一 个 Set 的 方 法 只 有 一 个 : 迭 代 器 (interator) HashSet 中 元 素 是 无 序 的 ( 这 个 无 序 指 的 是 数 据 的 添 加 顺 序 和 后 来 的 排 列 顺 序 不 同 ), 而 且 元 素 不 可 重 复 在 Object 中 除 了 有 final(),tostring(),equals(), 还 有 hashcode() HashSet 底 层 用 的 也 是 数 组 当 向 数 组 中 利 用 add(object o) 添 加 对 象 的 时 候, 系 统 先 找 对 象 的 hashcode: int hc=o.hashcode(); 返 回 的 hashcode 为 整 数 值 Int I=hc%n;(n 为 数 组 的 长 度 ), 取 得 余 数 后, 利 用 余 数 向 数 组 中 相 应 的 位 置 添 加 数 据, 以 n 为 6 为 例, 如 果 I=0 则 放 在 数 组 a[0] 位 置, 如 果 I=1, 则 放 在 数 组 a[1] 位 置 如 果 equals() 返 回 的 值 为 true, 则 说 明 数 据 重 复 如 果 equals() 返 回 的 值 为 false, 则 再 找 其 他 的 位 置 进 行 比 较 这 样 的 机 制 就 导 致 两 个 相 同 的 对 象 有 可 能 重 复 地 添 加 到 数 组 中, 因 为 他 们 的 hashcode 不 同 如 果 我 们 能 够 使 两 个 相 同 的 对 象 具 有 相 同 hashcode, 才 能 在 equals() 返 回 为 真 在 实 例 中, 定 义 student 对 象 时 覆 盖 它 的 hashcode 因 为 String 类 是 自 动 覆 盖 的, 所 以 当 比 较 String 类 的 对 象 的 时 候, 就 不 会 出 现 有 两 个 相 同 的 string 对 象 的 情 况 现 在, 在 大 部 分 的 JDK 中, 都 已 经 要 求 覆 盖 了 hashcode 结 论 : 如 将 自 定 义 类 用 hashset 来 添 加 对 象, 一 定 要 覆 盖 hashcode() 和 equals(), 覆 盖 的 原 则 是 保 证 当 两 个 对 象 hashcode 返 回 相 同 的 整 数, 而 且 equals() 返 回 值 为 True 如 果 偷 懒, 没 有 设 定 equals(), 就 会 造 成 返 回 hashcode 虽 然 结 果 相 同, 但 在 程 序 执 行 的 过 程 中 会 多 次 地 调 用 equals(), 从 而 影 响 程 序 执 行 的 效 率 我 们 要 保 证 相 同 对 象 的 返 回 的 hashcode 一 定 相 同, 也 要 保 证 不 相 同 的 对 象 的 hashcode 尽 可 能 不 同 ( 因 为 数 组 的 边 界 性,hashCode 还 是 可 能 相 同 的 ) 例 子 : public int hashcode(){ return name.hashcode()+age; 这 个 例 子 保 证 了 相 同 姓 名 和 年 龄 的 记 录 返 回 的 hashcode 是 相 同 的 使 用 hashset 的 优 点 : hashset 的 底 层 是 数 组, 其 查 询 效 率 非 常 高 而 且 在 增 加 和 删 除 的 时 候 由 于 运 用 的 hashcode 的 比 较 开 确 定 添 加 元 素 的 位 置, 所 以 不 存 在 元 素 的 偏 移, 所 以 效 率 也 非 常 高 因 为 hashset 查 询 和 删 除 和 增 加 元 素 的 效 率 都 非 常 高 但 是 hashset 增 删 的 高 效 率 是 通 过 花 费 大 量 的 空 间 换 来 的 : 因 为 空 间 越 大, 取 余 数 相 同 的 情 况 就 越 小 HashSet 这 种 算 法 会 建 立 许 多 无 用 的 空 间 使 用 hashset 接 口 时 要 注 意, 如 果 发 生 冲 突, 就 会 出 现 遍 历 整 个 数 组 的 情 况, 这 样 就 使 得 效 率 非 常 的 低 练 习 :new 一 个 hashset, 插 入 employee 对 象, 不 允 许 重 复, 并 且 遍 历 出 来 添 加 知 识 点 : 集 合 对 象 存 放 的 是 一 系 列 对 象 的 引 用 例 : Student S Al.add(s); s.setname( lucy ); Student s2=(student)(al.get(o1)); 可 知 s2 也 是 s

19 12.05 SortedSet 可 自 动 为 元 素 排 序 SortedSet 的 实 现 类 是 TreeSet: 它 的 作 用 是 字 为 添 加 到 TreeSet 中 的 元 素 排 序 练 习 : 自 定 义 类 用 TreeSet 排 序 与 HashSet 不 同,TreeSet 并 不 需 要 实 现 HashCode() 和 equals() 只 要 实 现 compareable 和 compareto() 接 可 以 实 现 过 滤 功 能 ( 注 :HashSet 不 调 用 CompareTo()) 如 果 要 查 询 集 合 中 的 数 据, 使 用 Set 必 须 全 部 遍 历, 所 以 查 询 的 效 率 低 使 用 Map, 可 通 过 查 找 key 得 到 value, 查 询 效 率 高 集 合 中 常 用 的 是 :ArrayList,HashSet,HashMap 其 中 ArrayList 和 HashMap 使 用 最 为 广 泛 使 用 HashMap,put() 表 示 放 置 元 素,get() 表 示 取 元 素 遍 历 Map, 使 用 keyset() 可 以 返 回 set 值, 用 keyset() 得 到 key 值, 使 用 迭 代 器 遍 历, 然 后 使 用 put() 得 到 value 值 上 面 这 个 算 法 的 关 键 语 句 : Set s=m.keyset(); Interator it=new interator(); Object key=it.next(); Object value=m.get(key); 注 意 :HashMap 与 HashCode 有 关, 用 Sort 对 象 排 序 如 果 在 HashMap 中 有 key 值 重 复, 那 么 后 面 一 条 记 录 的 value 覆 盖 前 面 一 条 记 录 Key 值 既 然 可 以 作 为 对 象, 那 么 也 可 以 用 一 个 自 定 义 的 类 比 如 : m.put(new sutdent( Liucy,30), boss ) 如 果 没 有 语 句 来 判 定 Student 类 对 象 是 否 相 同, 则 会 全 部 打 印 出 来 当 我 们 用 自 定 义 的 类 对 象 作 为 key 时, 我 们 必 须 在 程 序 中 覆 盖 HashCode() 和 equals() 注 :HashMap 底 层 也 是 用 数 组,HashSet 底 层 实 际 上 也 是 HashMap,HashSet 类 中 有 HashMap 属 性 ( 我 们 如 何 在 API 中 查 属 性 ) HashSet 实 际 上 为 (key.null) 类 型 的 HashMap 有 key 值 而 没 有 value 值 正 因 为 以 上 的 原 因,TreeSet 和 TreeMap 的 实 现 也 有 些 类 似 的 关 系 注 意 :TreeSet 和 TreeMap 非 常 的 消 耗 时 间, 因 此 很 少 使 用 我 们 应 该 熟 悉 各 种 实 现 类 的 选 择 非 常 体 现 你 的 功 底 HashSet VS TreeSet:HashSet 非 常 的 消 耗 空 间,TreeSet 因 为 有 排 序 功 能, 因 此 资 源 消 耗 非 常 的 高, 我 们 应 该 尽 量 少 使 用, 而 且 最 好 不 要 重 复 使 用 基 于 以 上 原 因, 我 们 尽 可 能 的 运 用 HashSet 而 不 用 TreeSet, 除 非 必 须 排 序 同 理 :HashMap VS TreeMap: 一 般 使 用 HashMap, 排 序 的 时 候 使 用 TreeMap HashMap VS Hashtable( 注 意 在 这 里 table 的 第 一 个 字 母 小 写 ) 之 间 的 区 别 有 些 类 似 于 ArrayList 和 Vector,Hashtable 是 重 量 级 的 组 件, 在 考 虑 并 发 的 情 况, 对 安 全 性 要 求 比 较 高 的 时 候 使 用

20 Map 的 运 用 非 常 的 多 使 用 HashMap(), 如 果 使 用 自 定 义 类, 一 定 要 覆 盖 HashCode() 和 equals() 重 点 掌 握 集 合 的 四 种 操 作 : 增 加 删 除 遍 历 排 序 Module8 12 利 用 两 天 的 时 间 完 成 Module8: 图 形 界 面 Module9: 事 件 模 型 ( 在 本 部 分 最 重 要 ) Module10:AWT Module11:Swing Module12:Applet( 这 个 技 术 基 本 已 经 被 淘 汰 ) 软 件 应 用 的 三 个 发 展 阶 段 : 单 机 应 用 网 络 应 用 (C/S 结 构 ) BS 结 构 :B 表 示 浏 览 器,S 表 示 server 端 即 利 用 浏 览 器 作 为 客 户 端, 因 此 对 于 图 形 界 面 的 要 求 已 经 不 高, 现 在 的 发 展 趋 势 是 不 使 用 安 装, 即 不 用 任 何 的 本 地 应 用, 图 形 很 快 就 会 被 服 务 器 构 件 开 发 所 取 代 经 验 之 谈 :Swing 的 开 发 工 作 会 非 常 的 累, 而 且 这 项 技 术 正 在 走 向 没 落 避 免 从 事 有 这 种 特 征 的 工 作 AWT 也 即 将 被 取 代 Module8 Module11 所 使 用 的 技 术 都 将 被 JSF 技 术 所 取 代 JSF 是 服 务 器 端 的 Swing: 目 前 技 术 已 经 成 熟, 但 是 开 发 环 境 ( 工 具 ) 还 不 成 熟 Module12 的 Applet 技 术 也 将 被 WebStart 所 取 代 Module9 为 重 点, 所 谓 事 件 模 型 是 指 观 察 者 设 计 模 式 的 JAVA 应 用 事 件 模 型 是 重 点 Module8: 图 形 界 面 (java.awt.*) Awt: 抽 象 窗 口 工 具 箱, 它 由 三 部 分 组 成 : 1 组 件 : 界 面 元 素 ; 2 容 器 : 装 载 组 件 的 容 器 ( 例 如 窗 体 ); 3 布 局 管 理 器 : 负 责 决 定 容 器 中 组 件 的 摆 放 位 置 图 形 界 面 的 应 用 分 四 步 : 1 选 择 一 个 容 器 : ⑴window: 带 标 题 的 容 器 ( 如 Frame); ⑵Panel: 面 板 通 过 add() 想 容 器 中 添 加 组 件 Java 的 图 形 界 面 依 然 是 跨 平 台 的 但 是 在 调 用 了 一 个 窗 体 之 后 只 生 成 一 个 窗 体, 没 有 事 件 的 处 理, 关 闭 按 钮 并 不 工 作 此 时 只 能 使 用 CTRL+C 终 止 程 序 2 设 置 一 个 布 局 管 理 器 : 用 setlayout(); 3 向 容 器 中 添 加 组 件 ; 3 添 加 组 件 的 事 务 处 理 P198 P204:Panel 也 是 一 种 容 器 : 但 是 不 可 见 的 在 设 置 容 易 的 时 候 不 要 忘 记 设 置 它 们 的 可 见 性 Panel pan=new Panel; Fp.setLayout(null); 表 示 不 要 布 局 管 理 器

21 五 种 布 局 管 理 器 : P206:Flow Layout( 流 式 布 局 ): 按 照 组 件 添 加 到 容 器 中 的 顺 序, 顺 序 排 放 组 件 位 置 默 认 为 水 平 排 列, 如 果 越 界 那 么 会 向 下 排 列 排 列 的 位 置 随 着 容 器 大 小 的 改 变 而 改 变 Panel 默 认 的 布 局 管 理 器 为 Flow Layout Border Layout: 会 将 容 器 非 常 五 个 区 域 : 东 西 南 北 中 语 句 : Button b1=new Botton( north );//botton 上 的 文 字 f.add(b1, North );// 表 示 b1 这 个 botton 放 在 north 位 置 注 : 一 个 区 域 只 能 放 置 一 个 组 件, 如 果 想 在 一 个 区 域 放 置 多 个 组 件 就 需 要 使 用 Panel 来 装 载 Frame 和 Dialog 的 默 认 布 局 管 理 器 是 Border Layout Grid Layout: 将 容 器 生 成 等 长 等 大 的 条 列 格, 每 个 块 中 放 置 一 个 组 件 f.setlayout GridLayout(5,2,10,10)// 表 示 条 列 格 为 5 行 2 类, 后 面 为 格 间 距 CardLayout: 一 个 容 器 可 以 放 置 多 个 组 件, 但 每 次 只 有 一 个 组 件 可 见 ( 组 件 重 叠 ) 使 用 first(),last(),next() 可 以 决 定 哪 个 组 件 可 见 可 以 用 于 将 一 系 列 的 面 板 有 顺 序 地 呈 现 给 用 户 重 点 :GridBag Layout: 在 Grid 中 可 指 定 一 个 组 件 占 据 多 行 多 列,GridBag 的 设 置 非 常 的 烦 琐 Module9:AWT: 事 件 模 型 事 件 模 型 指 的 是 对 象 之 间 进 行 通 信 的 设 计 模 式 对 象 1 给 对 象 2 发 送 一 个 信 息 相 当 于 对 象 1 引 用 对 象 2 的 方 法 模 型 即 是 一 种 设 计 模 式 ( 约 定 俗 成 ) 对 象 对 为 三 种 : 1 事 件 源 : 发 出 事 件 者 ; 2 事 件 对 象 : 发 出 的 事 件 本 身 ; 4 事 件 监 听 器 : 提 供 处 理 事 件 指 定 的 方 法 Java AWT 事 件 模 型 也 称 为 授 权 事 件 模 型, 指 事 件 可 以 和 监 听 器 之 间 事 先 建 立 一 种 关 系 : 约 定 那 些 事 件 如 何 处 理, 由 谁 去 进 行 处 理 这 种 约 定 称 为 授 权 一 个 事 件 源 可 以 授 权 多 个 监 听 者 ( 授 权 也 称 为 监 听 者 的 注 册 ); 多 个 事 件 源 也 可 以 注 册 多 个 事 件 监 听 器 监 听 者 对 于 事 件 源 的 发 出 的 事 件 作 出 响 应 在 java.util 中 有 EventListener 接 口 : 所 有 事 件 监 听 者 都 要 实 现 这 个 接 口 java.util 中 有 EventObject 类 : 所 有 的 事 件 都 为 其 子 类 事 件 范 例 在 \CoreJava\Girl.java 文 件 中 ( 文 件 已 加 注 释 ) 注 意 : 接 口 因 对 不 同 的 事 件 监 听 器 对 其 处 理 可 能 不 同, 所 以 只 能 建 立 监 听 的 功 能, 而 无 法 实 现 处 理 下 面 程 序 建 立 监 听 功 能 : // 监 听 器 接 口 要 定 义 监 听 器 所 具 备 的 功 能, 定 义 方 法 { void WhatIdoWhenGirlHappy(EmotionEvent e);

22 void WhatIdoWhenGirlSad(EmotionEvent e); 注 意 查 看 参 考 书 : 事 件 的 设 置 模 式, 如 何 实 现 授 权 模 型 事 件 模 式 的 实 现 步 骤 : 开 发 事 件 对 象 ( 事 件 发 送 者 ) 接 口 接 口 实 现 类 设 置 监 听 对 象 一 定 要 理 解 透 彻 Gril.java 程 序 重 点 : 学 会 处 理 对 一 个 事 件 源 有 多 个 事 件 的 监 听 器 ( 在 发 送 消 息 时 监 听 器 收 到 消 息 的 排 名 不 分 先 后 ) 事 件 监 听 的 响 应 顺 序 是 不 分 先 后 的, 不 是 谁 先 注 册 谁 就 先 响 应 事 件 监 听 由 两 个 部 分 组 成 ( 接 口 和 接 口 的 实 现 类 ) 事 件 源 事 件 对 象 事 件 监 听 gril EmotinEvent EmotionListener( 接 口 ) Boy( 接 口 的 实 现 类 ) 鼠 标 事 件 :MouseEvent, 接 口 :MouseListener P235 ActionEvent 注 意 在 写 程 序 的 时 候 :import java.awt.*; 以 及 import java.awt.event.* 注 意 两 者 的 不 同 在 生 成 一 个 窗 体 的 时 候, 点 击 窗 体 的 右 上 角 关 闭 按 钮 激 发 窗 体 事 件 的 方 法 : 窗 体 Frame 为 事 件 源, WindowsListener 接 口 调 用 Windowsclosing() 为 了 配 合 后 面 的 实 现, 我 们 必 须 将 WindowsListener 所 有 的 方 法 都 实 现, 除 了 Windowsclosing 方 法, 其 余 的 方 法 均 为 空 实 现 ( 练 习 : 写 一 个 带 button 窗 体, 点 关 闭 按 钮 退 出 ) 上 面 程 序 中 实 现 了 许 多 不 必 要 的 实 现 类, 虽 然 是 空 实 现 为 了 避 免 上 面 那 些 无 用 的 实 现, 可 以 利 用 WindowEvent 的 一 个 WindowEvent 类, 还 是 利 用 windowslistener 还 有 WindowAdapter 类, 它 已 经 实 现 了 WindowsListener 它 给 出 的 全 部 都 是 空 实 现, 那 就 可 以 只 写 想 要 实 现 的 类, 去 覆 盖 其 中 的 类, 就 不 用 写 空 实 现 注 意 : 监 听 过 多, 会 抛 toomanylistener 例 外 Module 10 Canvas 组 件 : 画 布, 可 以 实 现 动 画 操 作 TextArea: 文 本 域 在 单 行 文 本 域 中 回 车 会 激 发 ActionEvent 用 CheckBoxGroup 实 现 单 选 框 功 能 Java 中, 单 选 框 和 复 选 框 都 是 使 用 CheckBox 实 现 菜 单 :new MenuBar(),MenuBar 表 示 菜 单 条 菜 单 中 的 每 一 项 为 MenuItem, 一 般 级 联 菜 单 不 应 该 超 过 三 级 练 习 : 设 计 一 个 计 算 器 : 注 意 设 置 一 个 boolean 值 (append) 来 判 断 输 入 数 字 是 位 于 第 一 个 数 的 后 面 还 是 属 于 输 入 的 第 二 个 数 设 置 一 个 变 量 来 存 放 +, 点 完 运 算 符 后, 将 append 设 置 为 false String number1 Char operator 存 放 运 算 符 Module 11 Swing AWT 是 Java 最 早 出 现 的 图 形 界 面, 但 很 快 就 被 Swing 所 取 代 Swing 才 是 一 种 真 正 的 图 形 开 发

23 AWT 在 不 同 平 台 所 出 现 的 界 面 可 能 有 所 不 同 : 因 为 每 个 OS 都 有 自 己 的 UI 组 件 库,java 调 用 不 同 系 统 的 UI 注 意 AWT 为 重 量 级 组 件, 相 当 消 耗 资 源, 且 不 同 系 统 的 组 件 可 能 不 同 因 为 这 个 问 题 使 得 AWT 开 发 的 软 件 难 以 作 到 跨 平 台 更 为 要 命 的 是 : 不 同 OS 的 组 件 库 都 存 在 BUG 必 须 多 种 平 台 进 行 测 试, 并 且 AWT 的 组 件 库 并 不 丰 富 为 解 决 以 上 问 题,SUN 和 IBM 以 及 NETSCAPE 联 合 开 发 出 JAVA 基 础 类 包 Swing: 注 意 JAVA 的 基 础 类 以 Swing 为 核 心 注 意 引 用 :javax.swing.*;javax 表 示 JAVA 的 扩 展 我 们 在 学 习 JDBC 的 时 候 会 过 度 到 J2EE 在 Swing 的 组 件 中, 基 本 上 都 是 在 AWT 组 件 的 名 称 前 面 加 J 一 般 情 况 下, 除 了 Choise 等 组 件 : import javax.swing.*; 好 要 加 上 :import java.awt.* 以 及 import java.awt.event.* Swing 与 AWT 的 最 大 区 别 是 Swing 为 JAVA 自 身 的 组 件 已 经 不 是 对 等 实 体, 与 底 层 的 OS 无 关 (JBUILDER 就 是 使 用 Swing 写 的 ) Swing 与 AWT 在 事 件 模 型 处 理 上 是 一 致 的 Jframe 实 际 上 是 一 堆 窗 体 的 叠 加 Swing 比 AWT 更 加 复 杂 且 灵 活 在 JDK1.4 中, 给 JFRAME 添 加 Button 不 可 用 jf.add(b) 而 是 使 用 jf.getcontentpane().add(b) content 是 先 申 请 面 板 不 过 在 JDK1.5 中 可 以 使 用 add. Jpanel 支 持 双 缓 冲 技 术 在 Jbutton 中 可 以 添 加 图 标 JscrollPane 可 以 管 理 比 屏 幕 还 要 大 的 组 件 TextArea 只 有 装 入 JscrollPane 中 才 能 实 现 滚 动 条 JeditorPane 用 于 显 示 浏 览 器 注 意 :Tabbed Panel 与 Border 的 比 较 进 度 条 :ProgressBar JcomboBox: 下 拉 菜 单 : 在 AWT 中 同 类 组 件 是 choice JlistPanel: 选 择 列 表 BorderPanel: 设 置 边 框 JsplitPanel: 可 将 容 器 分 为 两 个 部 分, 其 中 一 个 部 分 有 Jtree TextBox: 也 是 一 种 新 的 容 器, 可 以 设 置 组 件 的 间 距 TextFileChoose: 文 件 选 择 器 ColorChoose: 颜 色 选 择 器 Module 12 Applet Applet 为 Panel 的 子 类 Applet 是 java 的 自 动 执 行 方 式 ( 这 是 它 的 优 势, 主 要 用 于 HTML) 工 作 四 种 语 法 :init(),start(),stop(),destory() Swing 中 有 一 个 Japplet, 如 使 用 Swing 组 件 Applet 消 亡 的 原 因 : 1java 为 安 全 起 见 对 Applet 有 所 限 制 :Applet 不 允 许 访 问 本 地 文 件 信 息 敏 感 信 息, 不 能 执 行 本 地 指 令 ( 比 如 FORMAT), 不 能 访 问 初 原 服 务 器 之 外 的 其 他 服 务 器 2 IE 不 支 持 新 版 本 的 Applet Applet 的 优 势 : 网 络 传 输, 自 动 下 载

24 Application 的 优 势 : 没 有 执 行 限 制 WebStart: 可 在 网 络 传 输, 并 且 在 本 地 无 限 制 因 此 前 景 光 明 练 习 : 使 用 Swing 实 现 一 个 界 面, 分 为 上 下 两 个 部 分, 南 边 为 JtextField 组 件, 可 编 辑, 上 面 为 JtextArea 组 件, 不 可 编 辑, 在 JtextField 组 件 输 入 字 符, 按 回 车, 就 可 以 将 内 容 输 入 到 JtextArea 组 件 (AREA 区 域 可 以 滚 动 ) 多 线 程 进 程 : 任 务 任 务 并 发 执 行 是 一 个 宏 观 概 念, 微 观 上 是 串 行 的 进 程 的 调 度 是 有 OS 负 责 的 ( 有 的 系 统 为 独 占 式, 有 的 系 统 为 共 享 式, 根 据 重 要 性, 进 程 有 优 先 级 ) 由 OS 将 时 间 分 为 若 干 个 时 间 片 JAVA 在 语 言 级 支 持 多 线 程 分 配 时 间 的 仍 然 是 OS 参 看 P377 线 程 由 两 种 实 现 方 式 : 第 一 种 方 式 : class MyThread extends Thread{ public void run(){ 需 要 进 行 执 行 的 代 码, 如 循 环 public class TestThread{ main(){ Thread t1=new Mythread(); T1.start(); 只 有 等 到 所 有 的 线 程 全 部 结 束 之 后, 进 程 才 退 出 第 二 种 方 式 : Class MyThread implements Runnable{ Public void run(){ Runnable target=new MyThread(); Thread t3=new Thread(target); Thread.start();// 启 动 线 程 P384: 通 过 接 口 实 现 继 承

25 练 习 : 写 两 个 线 程 : 1 输 入 200 个 ### 2 输 入 200 个 *** 下 面 为 线 程 中 的 7 中 非 常 重 要 的 状 态 :( 有 的 书 上 也 只 有 认 为 前 五 种 状 态 : 而 将 锁 池 和 等 待 队 列 都 看 成 是 阻 塞 状 态 的 特 殊 情 况 : 这 种 认 识 也 是 正 确 的, 但 是 将 锁 池 和 等 待 队 列 单 独 分 离 出 来 有 利 于 对 程 序 的 理 解 ) 初 始 Start() 阻 塞 DEAD 1 ⑴ 2 ⑵ 3 ⑶ run() 结 束 可 运 行 OS 分 配 CPU CPU 时 间 片 结 束 yield() 运 行 等 待 锁 标 记 o.wait() 锁 池 等 待 队 列 notify() 注 意 : 图 中 标 记 依 次 为 1 输 入 完 毕 ;2wake up3t1 退 出 ⑴ 如 等 待 输 入 ( 输 入 设 备 进 行 处 理, 而 CUP 不 处 理 ), 则 放 入 阻 塞, 直 到 输 入 完 毕 ⑵ 线 程 休 眠 sleep() ⑶t1.join() 指 停 止 main(), 然 后 在 某 段 时 间 内 将 t1 加 入 运 行 队 列, 直 到 t1 退 出,main() 才 结 束 特 别 注 意 :123 与 ⑴⑵⑶ 是 一 一 对 应 的 进 程 的 休 眠 :Thread sleep(1000);// 括 号 中 以 毫 秒 为 单 位 当 main() 运 行 完 毕, 即 使 在 结 束 时 时 间 片 还 没 有 用 完,CPU 也 放 弃 此 时 间 片, 继 续 运 行 其 他 程 序 Try{Thread.sleep(1000); Catch(Exception e){e.printstacktrace(e); T1.join() 表 示 运 行 线 程 放 弃 执 行 权, 进 入 阻 塞 状 态 当 t1 结 束 时,main() 可 以 重 新 进 入 运 行 状 态 T1.join 实 际 上 是 把 并 发 的 线 程 编 程 并 行 运 行 线 程 的 优 先 级 :1-10, 越 大 优 先 级 越 高, 优 先 级 越 高 被 OS 选 中 的 可 能 性 就 越 大 ( 不 建 议 使 用, 因 为 不 同 操 作 系 统 的 优 先 级 并 不 相 同, 使 得 程 序 不 具 备 跨 平 台 性, 这 种 优 先 级 只 是 粗 略 地 划 分 ) 注 : 程 序 的 跨 平 台 性 : 除 了 能 够 运 行, 还 必 须 保 证 运 行 的 结 果 一 个 使 用 yield() 就 马 上 交 出 执 行 权, 回 到 可 运 行 状 态, 等 待 OS 的 再 次 调 用 下 午 : 程 序 员 需 要 关 注 的 线 程 同 步 和 互 斥 的 问 题 多 线 程 的 并 发 一 般 不 是 程 序 员 决 定, 而 是 由 容 器 决 定 多 线 程 出 现 故 障 的 原 因 : 两 个 线 程 同 时 访 问 一 个 数 据 资 源 ( 临 界 资 源 ), 形 成 数 据 发 生 不 一 致 和 不 完 整 数 据 的 不 一 致 往 往 是 因 为 一 个 线 程 中 的 两 个 关 联 的 操 作 只 完 成 了 一 步

26 避 免 以 上 的 问 题 可 采 用 对 数 据 进 行 加 锁 的 方 法 每 个 对 象 除 了 属 性 和 方 法, 都 有 一 个 monitor( 互 斥 锁 标 记 ), 用 来 将 这 个 对 象 交 给 一 个 线 程, 只 有 拿 到 monitor 的 线 程 才 能 够 访 问 这 个 对 象 Synchronized: 这 个 修 饰 词 可 以 用 来 修 饰 方 法 和 代 码 块 Object obj; Obj.setValue(123); Synchronized 用 来 修 饰 方 法, 表 示 当 某 个 线 程 调 用 这 个 方 法 之 后, 其 他 的 事 件 不 能 再 调 用 这 个 方 法 只 有 拿 到 obj 标 记 的 线 程 才 能 够 执 行 代 码 块 注 意 :Synchronized 一 定 使 用 在 一 个 方 法 中 锁 标 记 是 对 象 的 概 念, 加 锁 是 对 对 象 加 锁, 目 的 是 在 线 程 之 间 进 行 协 调 当 用 Synchronized 修 饰 某 个 方 法 的 时 候, 表 示 该 方 法 都 对 当 前 对 象 加 锁 给 方 法 加 Synchronized 和 用 Synchronized 修 饰 对 象 的 效 果 是 一 致 的 一 个 线 程 可 以 拿 到 多 个 锁 标 记, 一 个 对 象 最 多 只 能 将 monitor 给 一 个 线 程 Synchronized 是 以 牺 牲 程 序 运 行 的 效 率 为 代 价 的, 因 此 应 该 尽 量 控 制 互 斥 代 码 块 的 范 围 方 法 的 Synchronized 特 性 本 身 不 会 被 继 承, 只 能 覆 盖 线 程 因 为 未 拿 到 锁 标 记 而 发 生 的 阻 塞 不 同 于 前 面 五 个 基 本 状 态 中 的 阻 塞, 称 为 锁 池 每 个 对 象 都 有 自 己 的 一 个 锁 池 的 空 间, 用 于 放 置 等 待 运 行 的 线 程 这 些 线 程 中 哪 个 线 程 拿 到 锁 标 记 由 系 统 决 定 锁 标 记 如 果 过 多, 就 会 出 现 线 程 等 待 其 他 线 程 释 放 锁 标 记, 而 又 都 不 释 放 自 己 的 锁 标 记 供 其 他 线 程 运 行 的 状 况 就 是 死 锁 死 锁 的 问 题 通 过 线 程 间 的 通 信 的 方 式 进 行 解 决 线 程 间 通 信 机 制 实 际 上 也 就 是 协 调 机 制 线 程 间 通 信 使 用 的 空 间 称 之 为 对 象 的 等 待 队 列, 则 个 队 列 也 是 属 于 对 象 的 空 间 的 Object 类 中 又 一 个 wait(), 在 运 行 状 态 中, 线 程 调 用 wait(), 此 时 表 示 着 线 程 将 释 放 自 己 所 有 的 锁 标 记, 同 时 进 入 这 个 对 象 的 等 待 队 列 等 待 队 列 的 状 态 也 是 阻 塞 状 态, 只 不 过 线 程 释 放 自 己 的 锁 标 记 Notify() 如 果 一 个 线 程 调 用 对 象 的 notify(), 就 是 通 知 对 象 等 待 队 列 的 一 个 线 程 出 列 进 入 锁 池 如 果 使 用 notifyall() 则 通 知 等 待 队 列 中 所 有 的 线 程 出 列 注 意 : 只 能 对 加 锁 的 资 源 进 行 wait() 和 notify() 释 放 锁 标 记 只 有 在 Synchronized 代 码 结 束 或 者 调 用 wait() 注 意 锁 标 记 是 自 己 不 会 自 动 释 放, 必 须 有 通 知 注 意 在 程 序 中 判 定 一 个 条 件 是 否 成 立 时 要 注 意 使 用 WHILE 要 比 使 用 IF 要 严 密 WHILE 会 放 置 程 序 饶 过 判 断 条 件 而 造 成 越 界 补 充 知 识 : suspend() 是 将 一 个 运 行 时 状 态 进 入 阻 塞 状 态 ( 注 意 不 释 放 锁 标 记 ) 恢 复 状 态 的 时 候 用 resume() Stop() 指 释 放 全 部 这 几 个 方 法 上 都 有 Deprecated 标 志, 说 明 这 个 方 法 不 推 荐 使 用

27 一 般 来 说, 主 方 法 main() 结 束 的 时 候 线 程 结 束, 可 是 也 可 能 出 现 需 要 中 断 线 程 的 情 况 对 于 多 线 程 一 般 每 个 线 程 都 是 一 个 循 环, 如 果 中 断 线 程 我 们 必 须 想 办 法 使 其 退 出 如 果 主 方 法 main() 想 结 束 阻 塞 中 的 线 程 ( 比 如 sleep 或 wait) 那 么 我 们 可 以 从 其 他 进 程 对 线 程 对 象 调 用 interrupt() 用 于 对 阻 塞 ( 或 锁 池 ) 会 抛 出 例 外 Interrupted Exception 这 个 例 外 会 使 线 程 中 断 并 执 行 catch 中 代 码 多 线 程 中 的 重 点 : 实 现 多 线 程 的 两 种 方 式,Synchronized, 以 及 生 产 者 和 消 费 者 问 题 (ProducerConsumer.java 文 件 ) 练 习 : 1 存 车 位 的 停 开 车 的 次 序 输 出 问 题 ; 2 写 两 个 线 程, 一 个 线 程 打 印 1-52, 另 一 个 线 程 答 应 字 母 A-Z 打 印 顺 序 为 12A34B56C 5152Z 通 过 使 用 线 程 之 间 的 通 信 协 调 关 系 注 : 分 别 给 两 个 对 象 构 造 一 个 对 象 o, 数 字 每 打 印 两 个 或 字 母 每 打 印 一 个 就 执 行 o.wait() 在 o.wait() 之 前 不 要 忘 了 写 o.notify() 补 充 说 明 : 通 过 Synchronized, 可 知 Vector 较 ArrayList 方 法 的 区 别 就 是 Vector 所 有 的 方 法 都 有 Synchronized 所 以 Vector 更 为 安 全 同 样 :Hashtable 较 HashMap 也 是 如 此 Module 10:I/O 流 (java 如 何 实 现 与 外 界 数 据 的 交 流 ) Input/Output: 指 跨 越 出 了 JVM 的 边 界, 与 外 界 数 据 的 源 头 或 者 目 标 数 据 源 进 行 数 据 交 换 输 出 JMV 数 据 源 输 入 注 意 : 输 入 / 输 出 是 针 对 JVM 而 言 File 类 (java.io.*) 可 表 示 一 个 文 件, 也 有 可 能 是 一 个 目 录 ( 在 JAVA 中 文 件 和 目 录 都 属 于 这 个 类 中, 而 且 区 分 不 是 非 常 的 明 显 ) Java.io 下 的 方 法 是 对 磁 盘 上 的 文 件 进 行 磁 盘 操 作, 但 是 无 法 读 取 文 件 的 内 容 注 意 : 创 建 一 个 文 件 对 象 和 创 建 一 个 文 件 在 JAVA 中 是 两 个 不 同 的 概 念 前 者 是 在 虚 拟 机 中 创 建 了 一 个 文 件, 但 却 并 没 有 将 它 真 正 地 创 建 到 OS 的 文 件 系 统 中, 随 着 虚 拟 机 的 关 闭, 这 个 创 建 的 对 象 也 就 消 失 了 而 创 建 一 个 文 件 才 是 在 系 统 中 真 正 地 建 立 一 个 文 件 例 如 :File f=new File( 11.txt );// 创 建 一 个 名 为 11.txt 的 文 件 对 象 f.createnewfile(); // 真 正 地 创 建 文 件 f.createmkdir(): 创 建 目 录 f.delete(); 删 除 文 件 f.deleteonexit(); 在 进 程 退 出 的 时 候 删 除 文 件, 这 样 的 操 作 通 常 用 在 临 时 文 件 的 删 除 对 于 命 令 :File f2=new file( d:\\abc\\789\\1.txt ) 这 个 命 令 不 具 备 跨 平 台 性, 因 为 不 同 的 OS 的 文 件 系 统 很 不 相 同 如 果 想 要 跨 平 台, 在 file 类 下 有 separtor(), 返 回 锁 出 平 台 的 文 件 分 隔 符 File.fdir=new File(File.separator);

28 String str= abc +File.separator+ 789 ; 使 用 文 件 下 的 方 法 的 时 候 一 定 注 意 是 否 具 备 跨 平 台 性 List(): 显 示 文 件 的 名 ( 相 对 路 径 ) ListFiles(): 返 回 Files 类 型 数 组, 可 以 用 getname() 来 访 问 到 文 件 名 使 用 isdirectory() 和 isfile() 来 判 断 究 竟 是 文 件 还 是 目 录 练 习 : 写 一 个 javatest 程 序, 列 出 所 有 目 录 下 的 *.java 文 件, 把 子 目 录 下 的 JAVA 文 件 也 打 印 出 来 使 用 I/O 流 访 问 file 中 的 内 容 JVM 与 外 界 通 过 数 据 通 道 进 行 数 据 交 换 分 类 : 按 流 分 为 输 入 流 和 输 出 流 ; 按 传 输 单 位 分 为 字 节 流 和 字 符 流 ; 还 可 以 分 为 节 点 流 和 过 滤 流 节 点 流 : 负 责 数 据 源 和 程 序 之 间 建 立 连 接 ; 过 滤 流 : 用 于 给 节 点 增 加 功 能 过 滤 流 的 构 造 方 式 是 以 其 他 流 位 参 数 构 造 ( 这 样 的 设 计 模 式 称 为 装 饰 模 式 ) 字 节 输 入 流 :io 包 中 的 InputStream 为 所 有 字 节 输 入 流 的 父 类 Int read(); 读 入 一 个 字 节 ( 每 次 一 个 ); 可 先 使 用 new byte[]= 数 组, 调 用 read(byte[] b) read (byte[]) 返 回 值 可 以 表 示 有 效 数 ;read (byte[]) 返 回 值 为 -1 表 示 结 束 字 节 输 出 流 :io 包 中 的 OutputStream 位 所 有 字 节 输 入 流 的 父 类 Write 和 输 入 流 中 的 read 相 对 应 在 流 中 close() 方 法 由 程 序 员 控 制 因 为 输 入 输 出 流 已 经 超 越 了 VM 的 边 界, 所 以 有 时 可 能 无 法 回 收 资 源 原 则 : 凡 是 跨 出 虚 拟 机 边 界 的 资 源 都 要 求 程 序 员 自 己 关 闭, 不 要 指 望 垃 圾 回 收 以 Stream 结 尾 的 类 都 是 字 节 流 如 果 构 造 FileOutputStream 的 同 时 磁 盘 会 建 立 一 个 文 件 如 果 创 建 的 文 件 与 磁 盘 上 已 有 的 文 件 名 重 名, 就 会 发 生 覆 盖 用 FileOutputStream 中 的 boolean, 则 视, 添 加 情 况, 将 数 据 覆 盖 重 名 文 件 还 是 将 输 入 内 容 放 在 文 件 的 后 面 ( 编 写 程 序 验 证 ) DataOutputStream: 输 入 数 据 的 类 型 因 为 每 中 数 据 类 型 的 不 同, 所 以 可 能 会 输 出 错 误 所 有 对 于 :DataOutputStream DataInputStream 两 者 的 输 入 顺 序 必 须 一 致 过 滤 流 : bufferedoutputstream bufferedinputstream 用 于 给 节 点 流 增 加 一 个 缓 冲 的 功 能 在 VM 的 内 部 建 立 一 个 缓 冲 区, 数 据 先 写 入 缓 冲 区, 等 到 缓 冲 区 的 数 据 满 了 之 后 再 一 次 性 写 出, 效 率 很 高 使 用 带 缓 冲 区 的 输 入 输 出 流 的 速 度 会 大 幅 提 高, 缓 冲 区 越 大, 效 率 越 高 ( 这 是 典 型 的 牺 牲 空 间 换 时 间 )

29 切 记 : 使 用 带 缓 冲 区 的 流, 如 果 数 据 数 据 输 入 完 毕, 使 用 flush 方 法 将 缓 冲 区 中 的 内 容 一 次 性 写 入 到 外 部 数 据 源 用 close() 也 可 以 达 到 相 同 的 效 果, 因 为 每 次 close 都 会 使 用 flush 一 定 要 注 意 关 闭 外 部 的 过 滤 流 ( 非 重 点 ) 管 道 流 : 也 是 一 种 节 点 流, 用 于 给 两 个 线 程 交 换 数 据 PipedOutputStream PipedInputStream 输 出 流 :connect( 输 入 流 ) RondomAccessFile 类 允 许 随 机 访 问 文 件 GetFilepoint() 可 以 知 道 文 件 中 的 指 针 位 置, 使 用 seek() 定 位 Mode( r : 随 机 读 ; w : 随 机 写 ; rw : 随 机 读 写 ) 练 习 : 写 一 个 类 A,JAVA A file1 file2 file1 要 求 是 系 统 中 已 经 存 在 的 文 件 File2 是 还 没 有 存 在 的 文 件 执 行 完 这 个 命 令, 那 么 file2 就 是 file1 中 的 内 容 字 符 流 :reader\write 只 能 输 纯 文 本 文 件 FileReader 类 : 字 符 文 件 的 输 出 字 节 流 与 字 符 流 的 区 别 : 字 节 流 的 字 符 编 码 : 字 符 编 码 把 字 符 转 换 成 数 字 存 储 到 计 算 机 中, 按 ASCii 将 字 母 映 射 为 整 数 把 数 字 从 计 算 机 转 换 成 相 应 的 字 符 的 过 程 称 为 解 码 编 码 方 式 的 分 类 : ASCII( 数 字 英 文 ):1 个 字 符 占 一 个 字 节 ( 所 有 的 编 码 集 都 兼 容 ASCII) ISO8859-1( 欧 洲 ):1 个 字 符 占 一 个 字 节 GB-2312/GBK:1 个 字 符 占 两 个 字 节 Unicode: 1 个 字 符 占 两 个 字 节 ( 网 络 传 输 速 度 慢 ) UTF-8: 变 长 字 节, 对 于 英 文 一 个 字 节, 对 于 汉 字 两 个 或 三 个 字 节 原 则 : 保 证 编 解 码 方 式 的 统 一, 才 能 不 至 于 出 现 错 误 Io 包 的 InputStreamread 称 为 从 字 节 流 到 字 符 流 的 桥 转 换 类 这 个 类 可 以 设 定 字 符 转 换 方 式 OutputStreamred: 字 符 到 字 节 Bufferread 有 readline() 使 得 字 符 输 入 更 加 方 便 在 I/O 流 中, 所 有 输 入 方 法 都 是 阻 塞 方 法 Bufferwrite 给 输 出 字 符 加 缓 冲, 因 为 它 的 方 法 很 少, 所 以 使 用 父 类 printwrite, 它 可 以 使 用 字 节 流 对 象, 而 且 方 法 很 多 练 习 : 做 一 个 记 事 本 swing/jfilechoose: getselect file() InputStreeamReader: 把 字 节 变 为 字 符 JAVA 中 对 字 符 串 长 无 限 制 bufferedreader(ir)

30 12.09 class ObjectOutputStream 也 是 过 滤 流, 使 节 点 流 直 接 获 得 输 出 对 象 最 有 用 的 方 法 :WriteObject(Object b) 用 流 传 输 对 象 称 为 对 象 的 序 列 化, 但 并 不 使 所 有 的 对 象 都 可 以 进 行 序 列 化 的 只 有 在 实 现 类 时 必 须 实 现 一 个 接 口 :IO 包 下 的 Serializable( 可 序 列 化 的 ) 此 接 口 没 有 任 何 的 方 法, 这 样 的 接 口 称 为 标 记 接 口 Class Student implements Serializable 把 对 象 通 过 流 序 列 化 到 某 一 个 持 久 性 介 质 称 为 对 象 的 可 持 久 化 Hibernate 就 是 研 究 对 象 的 可 持 久 化 ObuectInputStream in =new ObjectInputStream; Object o1=in.readobuect(); Student s1=(student)o1; 注 意 : 因 为 o1 是 一 个 对 象, 因 为 需 要 对 其 进 行 保 存 Transient 用 来 修 饰 属 性 Transient int num; 表 示 当 我 们 对 属 性 序 列 化 时 忽 略 这 个 属 性 ( 即 忽 略 不 使 之 持 久 化 ) 所 有 属 性 必 须 都 是 可 序 列 化 的, 特 别 是 当 有 些 属 性 本 身 也 是 对 象 的 时 候, 要 尤 其 注 意 这 一 点 判 断 是 否 一 个 属 性 或 对 象 可 序 列 化 :Serialver Serialver TestObject(TestObject 必 须 为 已 经 编 译 ) 执 行 结 果 : 如 果 不 可 序 列 化 ; 则 出 现 不 可 序 列 化 的 提 示 如 果 可 以 序 列 化, 那 么 就 会 出 现 序 列 化 的 ID: UID java.until.* 有 StringTokenizer( 参 数 1, 参 数 2) 按 某 种 符 号 隔 开 文 件 StringTokenizer(s, : ) 用 : 隔 开 字 符,s 为 对 象 练 习 : 将 一 个 类 序 列 化 到 文 件, 然 后 读 出 下 午 : 1 网 络 基 础 知 识 2 JAVA 网 络 编 程 网 络 与 分 布 式 集 群 系 统 的 区 别 : 每 个 节 点 都 是 一 台 计 算 机, 而 不 是 各 种 计 算 机 内 部 的 功 能 设 备 Ip: 具 有 全 球 唯 一 性, 相 对 于 internet,ip 为 逻 辑 地 址 端 口 (port): 一 台 PC 中 可 以 有 个 端 口, 进 程 通 过 端 口 交 换 数 据 连 线 的 时 候 需 要 输 入 IP 也 需 要 输 入 端 口 信 息 计 算 机 通 信 实 际 上 的 主 机 之 间 的 进 程 通 信, 进 程 的 通 信 就 需 要 在 端 口 进 行 联 系 :21 协 议 : 为 了 进 行 网 络 中 的 数 据 交 换 ( 通 信 ) 而 建 立 的 规 则 标 准 或 约 定 不 同 层 的 协 议 是 不 同 的 网 络 层 : 寻 址 路 由 ( 指 如 何 到 达 地 址 的 过 程 ) 传 输 层 : 端 口 连 接 TCP 模 型 : 应 用 层 / 传 输 层 / 网 络 层 / 网 络 接 口 端 口 是 一 种 抽 象 的 软 件 结 构, 与 协 议 相 关 :TCP23 端 口 和 UDT23 端 口 为 两 个 不 同 的 概 念 端 口 应 该 用 1024 以 上 的 端 口, 以 下 的 端 口 都 已 经 设 定 功 能 套 接 字 (socket) 的 引 入 :

31 Ip+Port=Socket( 这 是 个 对 象 的 概 念 ) Socket 为 传 输 层 概 念, 而 JSP 是 对 应 用 层 编 程 例 : java.net.*; (Server 端 定 义 顺 序 ) ServerSocket(intport) Socket.accept();// 阻 塞 方 法, 当 客 户 端 发 出 请 求 是 就 恢 复 如 果 客 户 端 收 到 请 求 : 则 Socket SI=ss.accept(); 注 意 客 户 端 和 服 务 器 的 Socket 为 两 个 不 同 的 socket Socket 的 两 个 方 法 : getinputstream(): 客 户 端 用 getoutputstream() 服 务 器 端 用 使 用 完 毕 后 切 记 Socket.close(), 两 个 Socket 都 关, 而 且 不 用 关 内 部 的 流 在 client 端,Socket s=new Socket( ,8000); 为 一 个 默 认 本 机 的 地 址 练 习 : 1 客 户 端 向 服 务 器 发 出 一 个 字 符 串, 服 务 器 转 换 成 大 写 传 回 客 户 端 大 写 的 函 数 :String.toUpperCase() 2 服 务 器 告 诉 客 户 端 : 自 开 机 以 来 你 是 第 n 个 用 户 UDP 编 程 : DatagramSocket( 邮 递 员 ): 对 应 数 据 报 的 Socket 概 念, 不 需 要 创 建 两 个 socket, 不 可 使 用 输 入 输 出 流 DatagramPacket( 信 件 ): 数 据 包, 是 UDP 下 进 行 传 输 数 据 的 单 位, 数 据 存 放 在 字 节 数 组 中 UDP 也 需 要 现 有 Server 端, 然 后 再 有 Client 端 两 端 都 是 DatagramPacket( 相 当 于 电 话 的 概 念 ), 需 要 NEW 两 个 DatagramPacket InetAddress: 网 址 这 种 信 息 传 输 方 式 相 当 于 传 真, 信 息 打 包, 在 接 受 端 准 备 纸 模 式 : 发 送 端 :Server: DatagramPacket indatapacket=new DatagramPacket ((msg,msg.length); InetAdress.getByName(ip),port); 接 收 端 : clientaddress=indatapack.getaddress();// 取 得 地 址 clientport=indatapack.getport();// 取 得 端 口 号 datagramsocket.send; //Server datagramsocket.accept; //Client URL: 在 应 用 层 的 编 程 注 意 比 较 : // 查 找 网 络 服 务 器 的 目 录 file://directory // 查 找 本 地 的 文 件 系 统 java 的 开 发 主 要 以 http 为 基 础 反 射 : 主 要 用 于 工 具 和 框 架 的 开 发 反 射 是 对 于 类 的 再 抽 象 ; 通 过 字 符 串 来 抽 象 类 JAVA 类 的 运 行 :classloader: 加 载 到 虚 拟 机 (vm) Vm 中 只 能 存 储 对 象 ( 动 态 运 行 时 的 概 念 ),.class 文 件 加 载 到 VM 上 就 成 为 一 个 对 象, 同 时 初 始 静 态 成 员 及 静 态 代 码 ( 只 执 行 一 次 )