Java第一天 年4月23日

Transcription

1 Java 第 一 天 2007 年 4 月 23 日 1 Java 之 父 Golsling 1995 年 5 月 23 日 Java 诞 生 1998 年 12 月 1.2 版 本 Java2 J2SE J2EE J2ME 2004 年 12 月 1.5 版 本 (5.0) Java JavaSE JavaEE JavaME 2 Java SE --- Java 标 准 平 台 Java EE --- 企 业 级 平 台 Java ME --- 微 小 平 台, 用 在 资 源 受 限 的 平 台 上 3 ( 1) 跨 平 台 --- 一 次 编 译, 到 处 运 行 (2) 简 单 --- 简 化 C++, 取 消 了 指 针, 对 指 针 进 行 了 上 层 的 封 装, 它 保 证 能 够 通 过 这 个 指 针 ( 引 用 ), 来 访 问 有 效 的 内 存 单 元 父 类 不 允 许 多 继 承, 使 继 承 关 系 成 树 装 图, 每 个 类 都 只 能 由 一 个 java 语 言 的 开 发 效 率 高, 但 执 行 效 率 低 ( 相 当 于 c++ 的 55%) (3) 纯 面 向 对 象 的 语 言 --- 都 要 放 在 类 中 (4) 垃 圾 回 收 机 制 --- 自 动 垃 圾 收 集, 永 远 不 会 出 现 内 存 泄 露 的 问 题 4 虚 拟 机 java 语 言 是 先 编 译 后 解 释,java 源 码 是 通 过 编 译 生 成 一 种 特 殊 的.class 的 中 间 字 节 码 文 件, 然 后 再 由 JVM 进 行 解 释 运 行 ( 编 译 ) ( 解 释 ).java ---->.class ---> 可 执 行 文 件 所 以 效 率 低, 是 C++ 的 20 倍 5 java 源 代 码 中 的 main 方 法 的 定 义 写 法 main 方 法 是 程 序 的 入 口 public class Hello{ // 一 个 源 文 件 中 只 能 有 一 个 公 开 类, 而 且 源 文 件 的 文 件 名 与 公 开 类 的 类 名 完 全 一 致 public static void main(string[] args){ // 程 序 入 口 public static 可 以 调 换 顺 序 System.out.println("He llo world"); // 打 印 语 句 编 译 命 令 文 件 运 行 命 令 javac xxxx.java 源 文 件 的 名 字, 源 文 件 中 的 一 个 类 会 对 应 编 译 生 成 一 个.class java xxxx 类 的 名 字 --- 启 动 虚 拟 机 6 环 境 变 量 JAVA_HOME = /opt/jdk JDK 安 装 路 径 --- JDK = JRE {JVM( 硬 件 )+ 编 译 器 ( 软

2 件 ) + 编 译 器 工 具 + 类 库 PATH = $Path:$Java_Home/bin:. ClassPath =. 类 路 径 7 包 --- 分 类 放 置, 减 少 命 名 空 间 包 名. 类 名 表 示 一 个 类 的 全 限 定 名 java xxx.xxx.classa --- 运 行 时 要 在 包 结 构 的 上 一 层 目 录 来 运 行 javac -d. xxxx.java 文 件 在 当 前 目 录 --- 编 译 的 时 候, 按 照 包 结 构 存 放 字 节 码 文 件, 此 命 令 生 成 的.class package xxx.xxx, 包 的 定 义 在 一 个 程 序 中 只 能 由 一 个 import xxx.xxx.xxx.classa; --- 在 程 序 中 声 明 ClassA 类, 使 用 的 时 候 不 需 加 包 名, 使 用 同 一 包 内 的 类 时, 不 用 引 入 import p1.p2.p3.p4.p5.*; --- 声 明 p5 包 中 所 有 的 类, 不 能 代 表 其 子 包 系 统 会 在 每 个 java 程 序 中 隐 含 导 入 了 java.lang 这 个 包 8 java 中 的 注 释, 单 行 注 释 //... 多 行 注 释 /*...*/ 文 档 注 释 /**...<p>( 换 行 标 签 )*/, 用 javadoc 命 令 可 以 根 据 原 码 中 的 文 档 注 释 生 成 注 释 文 档 (html 格 式 ) 文 档 注 释 中 可 以 使 用 html 标 签 javadoc -d 路 径 ( 指 定 注 释 文 档 的 保 存 路 径 ) xxx.java 文 档 注 释 一 般 写 在 类 定 义 之 前, 方 法 之 前, 属 性 之 前 在 文 档 注 释 中 可 以 表 示 程 序 的 作 者,@version 表 示 程 序 的 版 本, 前 两 个 注 释 符 号 要 写 在 类 定 义 之 前, 用 于 方 法 的 注 对 参 数 进 行 注 释,@return 对 返 回 值 进 行 注 对 抛 出 异 常 的 注 释 10 标 识 符 规 则 --- 类, 方 法, 变 量, 同 时 也 是 包 名 的 规 范 开 头 由 字 母 ( 汉 语 中 的 一 个 汉 字 是 一 个 字 母 ), 数 字, 下 划 线 和 货 币 符 号 组 成, 不 能 以 数 字 大 小 写 敏 感 没 有 长 度 限 制, 不 能 有 空 格 不 能 使 用 Java 的 关 键 字 和 保 留 字 java 中 的 关 键 字 goto 和 const 在 java 中 虽 然 不 再 使 用 但 是 还 作 为 保 留 字 存 在 java 中 没 有 sizeof 这 个 关 键 字 了,java 中 的 boolean 类 型 的 值 只 能 用 true 和 false, 且 这 两 个 也 是 关 键 字 enum 枚 举 assert 断 言 一 个 标 识 符 尽 量 符 合 语 义 信 息, 提 高 程 序 可 读 性 类 名 : 每 个 单 词 首 字 母 大 写, 变 量 和 方 法 : 第 一 个 单 词 小 写, 后 边 的 每 个 单 词 首 字 母 大 写 包 常 名 : 全 部 小 写 量 : 全 部 大 写

3 11 局 部 变 量 : 定 义 在 方 法 中 的 变 量 (1) 先 赋 值 后 使 用 (2) 从 定 义 变 量 的 代 码 块 开 始 到 代 码 块 结 束 (3) 在 同 一 范 围 内 不 允 许 两 个 局 部 变 量 发 生 命 名 冲 突 Java 第 二 天 2007 年 4 月 24 日 1 Java 的 数 据 类 型 (1) 简 单 类 型 种 有 符 号 的 数 据 类 型 a) 整 型 byte 1 字 节 8 位 -128 到 127 short 2 字 节 16 位 -2^15 到 2^ 到 int 4 字 节 32 位 -2^31 到 2^ 到 整 型 值 存 放, 正 数 存 放 原 码 ( 二 进 制 码 ), 负 数 则 存 放 补 码 ( 原 码 按 位 取 反 末 位 加 一 ) long 8 字 节 64 位 -2^63 到 2^63-1 long a = 40000l; // 在 数 字 的 结 尾 加 l, 表 示 long 类 型 的 字 面 值 b) 浮 点 类 型 float 4 字 节 32 位 float a = 1.3f; double 8 字 节 64 位 double a = 1.3; double 和 long 比 较,double 表 示 的 数 值 要 大, 因 为 有 科 学 计 数 法 float a = 1.3; c) 字 符 类 型 char 2 字 节 16 位 d) 布 尔 型 //error 会 造 成 精 度 丢 失, 强 转 float a = (float)1.3; 或 者 float a = 1.3f; boolean false/true //Java 中 false 与 0 不 能 转 换 自 动 类 型 提 升 : a 运 算 符 b a 和 b 中 有 一 个 是 double, 结 果 就 是 double a 和 b 中 有 一 个 是 float, 结 果 就 是 float a 和 b 中 有 一 个 是 long, 结 果 就 是 long 除 以 上 之 外 的 情 况, 结 果 都 是 int char 是 无 符 号 的 16 位 整 数, 字 面 值 必 须 用 单 引 号 括 起 来 ; a String 是 类, 一 个 String 的 字 符 串 是 一 个 对 象, 非 原 始 数 据 类 型 ; 在 字 符 串 中 使 用 "+", 表 示 字 符 串 的 连 接, 系 统 重 载 了 这 个 运 算 符 char 类 型 也 可 以 用 通 用 转 译 字 符, 但 是 不 能 用 ASCII 码 可 以 用 \u0000 ( 十 六 进 制 ) 这 种 格 式, 因 为 char 型 中 使 用 的 是 unicode 编 码 方 式 char c1 = 'a'; char c2 = 97;

4 char c3 ='\u0061'; // 一 个 字 节 用 2 个 十 六 进 制 的 数 字 表 示 整 数 除 0 有 异 常,double 除 0 没 有 异 常 (2) 对 象 类 型 2 java 中 的 运 算 符 (java 的 运 算 符 的 优 先 级 和 结 合 性 和 c++ 相 同 ) *** System.out.println(3/2) 按 整 型 计 算 得 1 *** byte a = 1; a=a+2; // 不 合 法, 自 动 类 型 提 升, 赋 值 丢 失 精 度 a += 2 ; // 不 会 发 生 自 动 类 型 提 升 的, 合 法 a++ ; // 不 会 发 生 自 动 类 型 提 升 的 1) >>= 前 面 是 零 补 零, 前 面 是 一 补 一 ; 右 移 一 位 比 除 以 2 效 率 高 2) >>>= 无 符 号 右 移 ( 强 制 右 移 都 会 移 进 零 ), >>= 和 >>>= 对 于 负 数 不 一 样 正 数 : 右 移 n 位 等 于 除 以 2 的 n 次 方 负 数 : 变 成 正 数 3) && 短 路 与, 前 面 为 假, 表 达 式 为 假, 后 面 的 操 作 不 会 进 行,& 非 短 路 运 算 符, 会 对 所 有 条 件 进 行 判 断 断 例 : int a = 4; if(a<3&(b=a)==0) b 赋 值 if(a<3&&(b=a)==0) b 不 赋 值 4) 短 路 或, 前 面 为 真, 表 达 式 为 真, 后 面 的 操 作 不 会 进 行, 会 对 所 有 条 件 进 行 判 5)instanceof, 是 用 于 判 断 一 个 对 象 是 否 属 于 某 个 类 型 6)java 中 的 求 余 运 算 符 % 可 以 对 两 个 实 型 变 量 求 余 5%2=1 3 流 程 控 制 (1) 控 制 流 if() if().else if()..else if().else 注 意 :else 只 是 和 其 上 面 的 同 层 的 最 近 的 if() 来 配 对 (2)switch(s){ case 'a':.. case 1: break; default:

5 注 意 :switch() 内 数 据 类 型 为 byte short char int 类 型, 只 有 以 上 四 种 类 型 的 才 可 以 在 switch() 中 使 用 case 块 中 不 加 break 时 顺 序 执 行 下 面 的 语 句 4 循 环 语 句 for(int i=0;i<n;i++){ while(){ ---- 确 定 循 环 do{ while(); 注 意 加 分 号 ---- 循 环 0 或 多 次 循 环 1 或 多 次 5 语 法 在 main 方 法 中 要 使 用 全 局 变 量 或 调 用 其 他 方 法 时, 要 求 全 局 变 量 和 方 法 要 有 static 修 饰 命 令 行 参 数 args[0] = a args[0] = b 字 符 串 转 成 int 类 型 java Class a b int i = Integer.parseInt(a); 6 数 组 内 存 中 的 连 续 空 间 数 组 是 一 次 性 定 义 多 个 相 同 类 型 的 变 量 Java 中 一 个 数 组 就 是 一 个 对 象, 有 属 性, 没 有 方 法 int[] a; // 定 义 一 个 数 组, 变 量 名 就 是 指 向 数 组 首 地 址 的 指 针 a=new int[10]; // 为 数 组 分 配 空 间 a.length; // 得 到 数 组 的 长 度 数 组 创 建 后 有 初 始 值 : 数 字 类 型 为 0 布 尔 类 型 为 false 引 用 类 型 为 null String[] 默 认 值 null 初 始 化 创 建 和 声 明 在 同 一 时 间 int[] i = {0,1; // 显 示 初 始 化 int[] i = new int[]{0,1; // 注 意 : 这 样 显 示 的 初 始 化 的 时 候, new int[] 中 括 号 中 必 须 是 空 的, 不 能 填 数 字 Car[] c = {new Car(),new Car(); 数 组 拷 贝 System.arrayCopy(Object src, int srcpos, Object dest, int destpos, int length); src 源 数 组, srcpos 从 第 几 位 开 始 拷 贝 ( 数 组 下 标, 从 0 开 始 ),dest 目 标 数 组, destpos 目 标 数 组 放 置 的 起 始 位 置,length, 表 示 要 拷 贝 的 长 度 拷 贝 一 个 数 组 到 另 一 个 数 组 多 维 数 组 1) 有 效 定 义 int[][] i1 = new int[2][3]; ( 同 时 给 定 一 维, 二 维 的 空 间 ) int[][] i2 = new int[2][]; ( 给 定 一 维 的 空 间, 二 维 空 间 待 定, 不 规 则 的 二 维 数 组 ) i2[0] = new int[2],i2[1] = new int[3]; * C++ 中 int[][] =new int[][3]; 有 效

6 2) 无 效 定 义 int[][] i1 = new int[][3]; 3) 数 组 长 度 数 组 的 属 性 length( 在 二 维 数 组 中 这 个 属 性 只 代 表 第 一 维 的 长 度 ) int[] i = new int[5]; int len = i.length; //len = 5; Student[][] st = new Student[4][6]; len = st.length; //len = 4; len = st[0].length; //len = 6; 练 习 :(1) 数 组 元 素 的 偏 移 在 使 用 数 组 的 时 候, 通 常 使 用 一 个 辅 助 变 量 纪 录 数 组 中 的 有 效 元 素 的 个 数, 还 表 示 下 一 个 可 插 入 位 置 的 下 标 (2) 数 组 元 素 的 轮 换 偶 数 个 球 队 足 球 比 赛, 每 个 队 和 每 个 队 有 且 只 有 一 场 比 赛 把 数 字 按 "U" 字 型 摆 放, 左 边 最 上 边 的 数 字 不 变, 其 他 数 字 按 逆 时 针 旋 转 (3) 有 一 个 奇 阶 的 方 阵, 填 如 数 字, 使 得 第 一 个 数 一 定 放 在 第 一 行 的 最 中 间, 第 二 个 放 在 右 上 方, 行 越 界, 放 在 此 列 的 另 一 侧, 列 越 界 放 在 此 行 的 另 一 侧 行 列 都 越 界 的 时 候, 退 回 来, 放 在 原 来 的 数 字 下 边, 当 要 放 入 的 地 方 有 数 字 的 时 候, 退 回 来, 放 在 原 来 的 数 字 下 边 (1) public class ArrayInsertDelete{ static int[] a={1,2,3,4,5,6; static int index=6; static void insert(int pos,int value){ if (index==a.length) expand(); for(int i=index;i>pos;i--){ index++; a[i]=a[i-1]; a[pos]=value; static void delete(int pos){ index--; for(int i=pos;i<index;i++){ a[i]=a[i+1]; static void expand(){ int[] b=new int[a.length*2]; System.arraycopy(a,0,b,0,a.length); a=b;

7 static void print(){ for(int i=0;i<index;i++){ System.out.print(a[i]+"\t"); System.out.println(); public static void main(string[] args){ print(); insert(2,7); //{ 1,2,7,3,4,5,6 print(); delete(4); //{1,2,7,3,5,6 print(); Java 第 三 天 2007 年 4 月 25 日 1 面 向 对 象 的 思 想 anything is an Object( 万 物 皆 对 象 ) 符 合 人 们 客 观 看 待 世 界 的 规 律 2 抽 象, 从 对 具 体 的 对 象 中 抽 取 有 用 信 息 对 象 有 其 固 有 属 性, 对 象 的 方 法, 即 对 象 的 行 为 ( 对 象 能 做 什 么 ) 对 象 本 身 是 简 单 的 ( 功 能 简 单 ), 多 个 对 象 可 以 组 成 复 杂 的 系 统 ( 对 象 之 间 彼 此 调 用 对 方 的 方 法 ) 3 面 向 对 象 的 优 点 1) 对 象 应 当 是 各 司 其 职 ( 功 能 简 单 ), 各 尽 所 能 ( 把 自 己 的 功 能 作 到 最 好 ) ( 弱 耦 合 性 实 现 了 前 面 所 述 的 对 象 的 特 点 ) 2) 对 象 的 耦 合 性, 是 对 象 之 间 的 联 系, 对 象 和 系 统 之 间 的 联 系 对 象 的 耦 合 性 要 尽 量 的 弱, 也 就 是 对 象 之 间 的 联 系 尽 可 能 的 弱, 对 象 和 系 统 之 间 的 联 系 尽 可 能 的 弱 弱 耦 合 性 要 通 过 一 个 标 准 来 实 现 3) 可 重 用 性 对 象 的 功 能 越 简 单, 复 用 性 就 越 好 ( 对 象 的 耦 合 性 弱, 复 用 性 就 比 较 强 ) 4) 可 扩 展 性 系 统 的 可 插 入 性, 是 在 系 统 中 加 入 新 的 对 象 之 后 的 系 统 稳 定 性 对 象 的 可 替 换 性, 是 在 系 统 中 替 换 原 有 的 对 象 之 后 的 系 统 的 稳 定 性

8 4 面 向 过 程 和 面 向 对 象 的 比 较 面 向 过 程 是 先 有 算 法, 后 又 数 据 结 构 --- ( 怎 么 解 决 问 题 ) 面 向 对 象 是 先 有 对 象 ( 数 据 结 构 ), 后 有 算 法 ( 对 象 间 的 方 法 调 用 ) --- ( 用 什 么 做 ) 5 类 的 定 义 1) 属 性 类 型 变 量 名 ; --> 实 例 变 量, 系 统 赋 初 始 值 默 认 值 使 用 范 围 命 名 冲 突 实 例 变 量 系 统 赋 初 始 值 在 类 的 内 部 使 用 允 许 实 例 变 量 和 局 部 变 量 发 生 命 名 冲 突, 变 量 的 值 -> 局 部 优 先 局 部 变 量 先 赋 值 后 使 用 定 义 他 的 代 码 块 同 范 围 内 不 允 许 两 个 局 部 变 量 发 生 命 名 冲 突 2) 方 法 的 定 义 : 不 允 许 方 法 的 声 明 和 实 现 分 开 方 法 声 明 的 组 成 : (a) 方 法 的 修 饰 符 (0 或 多 个 修 饰 符 出 现 的 顺 序 无 关 ) (b) 方 法 的 返 回 值 类 型 (c) 方 法 名 (d) 方 法 的 参 数 表 (e) 方 法 中 允 许 抛 出 的 异 常 6 方 法 的 重 载 java 中 方 法 的 重 载 (overload) 方 法 名 相 同, 参 数 表 不 同 ( 个 数, 类 型, 排 列 顺 序 ), 其 他 部 分 可 以 不 同 调 用 时 要 给 出 明 确 参 数 并 确 定 调 用 某 一 方 法 在 编 译 时, 编 译 器 会 根 据 参 数 选 择 适 当 的 方 法, 所 以 重 载 也 叫 编 译 时 多 态 ** 方 法 的 重 载 可 以 屏 蔽 一 个 对 象 同 一 类 方 法 由 于 参 数 不 同 所 造 成 的 差 异 ** 顺 序 向 下 V 向 上 就 近 匹 配 原 则 如 果 方 法 的 参 数 表 中 的 数 据 类 型 和 调 用 时 给 出 的 参 数 类 型 不 尽 相 同 时 会 根 据 向 上 匹 配 的 就 近 原 则 ( 类 型 就 近 向 上 转 化 匹 配 ) public void m(byte a,short b){ System.out.println("m(byte,short)"); public void m(short a,byte b){ System.out.println("m(short,byte)"); 此 时 若 用 2 个 byte 作 为 参 数 调 用 m() 方 法, 编 译 会 出 错, 因 为 按 照 向 上 就 近 匹 配 原 则, 提 升 哪 个 都 可 以, 出 现 语 义 不 明 确 的 错 误 7 构 造 方 法

9 1) 方 法 名 与 类 名 相 同, 无 返 回 值 2) 系 统 提 供 默 认 无 参 的, 空 的 构 造 方 法 3) 若 自 定 义 一 个 有 参 的 构 造 方 法, 则 系 统 将 不 提 供 无 参 的, 空 的 构 造 方 法 不 能 手 工 调 用, 在 一 个 对 象 的 生 命 周 期 中, 只 会 被 调 用 一 次 8 对 象 的 创 建 Java 在 堆 中 创 建 对 象 的 过 程 : 1) 分 配 空 间 2) 初 始 化 属 性, 若 声 明 实 例 变 量 的 时 候 没 有 初 始 化, 用 默 认 值 初 始 化 属 性 3) 调 用 某 个 构 造 方 法 ( 前 提 : 不 考 虑 继 承 关 系 ) Student s; s = new Student(); 址 赋 给 一 个 Student 类 的 引 用 // 声 明 一 个 Student 类 的 对 象 变 量 // 调 用 Student 类 的 无 参 的 构 造 方 法, 创 建 一 个 对 象, 把 这 个 对 象 的 地 ( 引 用 指 向 了 这 个 对 象, 引 用 中 保 存 对 象 的 首 地 址, 以 后 都 是 通 过 引 用 访 问 这 个 对 象 的 属 性 和 方 法 ) s.age s 引 用 所 指 向 的 对 象 的 age 属 性 9 变 量 包 括 简 单 变 量 ( 原 始 数 据 类 型 ), 对 象 变 量 简 单 变 量 传 值, 对 象 变 量 传 址! static void method3(student s){ s=new Student(); // 创 建 一 个 新 对 象, 把 对 象 的 地 址 赋 给 形 参 的 引 用 s.age=20; // 改 变 新 对 象 的 状 态 Student stu=new Student(); System.out.println(stu.age); // 打 印 出 Student 类 的 age 属 性 的 初 始 值 method3(stu); //method3 方 法 返 回, 形 参 s 指 向 的 被 改 变 的 对 象 已 经 成 为 了 垃 圾 对 象 System.out.println(stu.age); // 打 印 的 仍 是 原 来 那 个 对 象 的 age 的 值 10 this 是 一 个 引 用, 指 向 的 是 自 己, 即 当 前 对 象 ( 哪 个 对 象 调 用 了 方 法, 哪 个 对 象 就 是 当 前 对 象 ) 可 以 用 来 区 分 实 例 变 量 和 局 部 变 量 this.age = age ; this(), 他 表 示 调 用 本 类 其 他 的 构 造 方 法, 注, 只 能 写 在 构 造 方 法 的 第 一 行 项 目 练 习 : 项 目 名 称 :Bank Account Management System 银 行 账 户 管 理 系 统 简 称 BAM 项 目 描 述 : 这 是 一 个 基 于 C/S 结 构 的 银 行 账 户 在 线 管 理 系 统, 用 户 可 以 通 过 ATM 终 端 界 面 来 操 作 自 己 的 银 行 账 户.

10 项 目 实 施 方 式 : 这 是 一 个 同 步 练 习, 随 着 达 内 CoreJava 课 程 的 深 入, 这 个 项 目 将 趋 于 完 整, 学 员 的 任 务 是 随 着 知 识 点 的 深 入, 完 成 每 一 个 进 阶 的 项 目 要 求. 练 习 1: ( 面 向 对 象 基 础 语 法 ) 写 一 个 账 户 类 (Account) 属 性 : id: 账 户 号 码 长 整 数 password: 账 户 密 码 String name: 真 实 姓 名 String personid: 身 份 证 号 码 String 客 户 的 电 子 邮 箱 String balance: 账 户 余 额 double 方 法 : deposit: 存 款 方 法, 参 数 是 double 型 的 金 额 withdraw: 取 款 方 法, 参 数 是 double 型 的 金 额 构 造 方 法 : 有 参 和 无 参, 有 参 构 造 方 法 用 于 设 置 必 要 的 属 性 Java 第 四 天 2007 年 4 月 25 日 1 复 习 面 向 对 象 思 想 符 合 我 们 看 待 客 观 世 界 的 规 律 Everything is an object 对 象 : 客 观 存 在, 有 什 么 ( 属 性 ), 能 做 什 么 ( 方 法 ) 每 个 对 象 都 是 简 单 的, 有 简 单 的 对 象 拼 装 成 复 杂 的 系 统 面 向 对 象 的 优 点 : 1) 各 司 其 职, 各 尽 所 能 2) 弱 耦 合 性 3) 可 重 用 性, 可 扩 展 性 类 : 对 象 共 性 的 抽 象, 客 观 对 象 在 人 脑 中 的 主 观 反 映 对 象 的 模 版 属 性 : 在 类 里, 但 在 任 何 方 法 之 外 定 义 的 一 个 变 量 --- 实 例 变 量 部 优 先,this 区 分 有 默 认 值, 访 问 范 围, 至 少 是 本 类 内 部, 可 以 和 局 部 变 量 发 生 命 名 上 的 冲 突, 局

11 方 法 : 方 法 定 义 ( 声 明 对 象 能 做 什 么 )/ 方 法 实 现 ( 怎 么 做 ) 定 义 : 修 饰 符 返 回 值 类 型 方 法 名 ( 参 数 表 ) 抛 出 的 异 常 重 载 (Overload): 方 法 名 相 同, 参 数 表 不 同 编 译 时 多 态, 编 译 器 根 据 参 数 表 选 择 一 个 方 法 为 什 么 要 有 方 法 的 重 载? 屏 蔽 一 个 对 象 同 一 类 方 法 由 于 参 数 表 不 同 所 造 成 的 差 异 就 近 向 上 匹 配 构 造 方 法 : 没 有 返 回 值, 方 法 名 和 类 名 是 相 同 的, 系 统 提 供 默 认 无 参 的 空 的 构 造 方 法, ** 建 议 自 己 写 无 参 构 造 构 造 对 象 的 过 程 : 1) 分 配 空 间 2) 初 始 化 属 性 3) 调 用 构 造 方 法 类 名 引 用 名 =new 类 名 ( 构 造 参 数 ); 方 法 参 数 传 递 规 则 : 简 单 类 型 参 数 : 传 值 对 象 类 型 参 数 : 传 引 用, 实 参 和 形 参 指 向 同 一 个 对 象 2 面 向 对 象 的 三 大 特 征 : 封 装 继 承 多 态 java 中 的 封 装 封 装, 一 个 对 象 和 外 界 的 联 系 应 当 通 过 一 个 统 一 的 接 口, 应 当 公 开 的 公 开, 应 当 隐 藏 的 隐 藏 ( 对 象 的 属 性 应 当 隐 藏 ), 一 个 对 象 的 内 部 是 透 明 的, 就 是 把 对 象 内 部 的 可 透 明 性 和 隐 藏 的 特 性 区 分 开, 该 透 明 的 透 明, 该 隐 藏 的 隐 藏 ( 封 装 的 属 性 )java 中 类 的 属 性 的 访 问 权 限 的 默 认 值 不 是 private, 要 想 隐 藏 该 属 性 或 方 法, 就 可 以 加 private( 私 有 ) 修 饰 符, 来 限 制 只 能 够 在 类 的 内 部 进 行 访 问 对 于 类 中 的 私 有 属 性, 要 对 其 给 出 一 对 方 法 (getxxx(),setxxx()) 访 问 私 有 属 性, 保 证 对 私 有 属 性 的 操 作 的 安 全 性 方 法 的 封 装, 对 于 方 法 的 封 装, 该 公 开 的 公 开, 该 隐 藏 的 隐 藏 方 法 公 开 的 是 方 法 的 声 明 ( 定 义 ), 即 ( 只 须 知 道 参 数 和 返 回 值 就 可 以 调 用 该 方 法 ), 隐 藏 方 法 的 实 现 会 使 实 现 的 改 变 对 架 构 的 影 响 最 小 化 封 装 会 使 方 法 实 现 的 改 变 对 架 构 的 影 响 最 小 化 完 全 的 封 装, 类 的 属 性 全 部 私 有 化, 并 且 提 供 一 对 方 法 来 访 问 属 性 方 法 Java Bean 一 种 组 件 规 范 --> 所 有 属 性 私 有, 访 问 方 法 按 照 命 名 规 范 setxxx(),getxxx() 3 java 中 的 继 承 继 承, 是 对 有 着 共 同 特 性 的 多 类 事 物, 进 行 再 抽 象 成 一 个 类 这 个 类 就 是 多 类 事 物 的 父

12 类 父 类 的 意 义 在 于 可 以 抽 取 多 类 事 物 的 共 性 泛 化 : 把 共 性 从 子 类 中 抽 取 出 来 特 化 : 现 有 父 类, 再 有 子 类 的 过 程 父 类 与 子 类 -> 从 一 般 到 特 殊 的 关 系 java 中 的 继 承 要 使 用 extends 关 键 字, 并 且 java 中 只 允 许 单 继 承, 也 就 是 一 个 类 只 能 有 一 个 直 接 的 父 类 这 样 就 是 继 承 关 系 呈 树 状, 体 现 了 java 的 简 单 性 子 类 只 能 继 承 在 父 类 中 可 以 访 问 的 属 性 和 方 法 ( 实 际 上 父 类 中 私 有 的 属 性 和 方 法 也 会 被 继 承 但 子 类 中 无 法 访 问 罢 了 ) 实 际 上 一 个 子 类 对 象 中 包 含 一 个 父 类 对 象 访 问 控 制 修 饰 符 :( 可 以 修 饰 属 性 和 方 法 ) private 修 饰 符, 表 示 只 有 本 类 内 部 可 以 访 问, 不 能 继 承 default 修 饰 符, 方 法 不 加 修 饰 符, 会 默 认 为 default, 表 示 在 同 一 个 包 中 可 以 访 问, 父 子 类 在 同 一 包 中, 子 类 可 以 继 承 父 类 的 相 应 内 容 ( 可 以 修 饰 类 ) protected( 保 护 ) 修 饰 符, 表 示 同 一 包 中 可 以 访 问, 不 同 包 的 子 类 也 可 以 访 问 继 承 public 修 饰 符, 表 示 公 开, 在 任 何 地 方 都 可 以 访 问, 能 继 承 ( 可 以 修 饰 类 ) 修 饰 符 的 权 限 是 由 上 而 下 逐 渐 变 宽 的 继 承 的 意 义, 就 在 于 子 类 可 以 在 父 类 的 基 础 之 上 对 父 类 的 功 能 进 行 发 展, 继 承 可 以 使 系 统 的 耦 合 性 降 低, 也 就 是 使 对 象 间 的 联 系 便 的 松 散, 使 多 类 对 象 间 的 联 系 用 其 父 类 对 象 代 替 注 意 : 构 造 方 法 不 能 被 继 承 父 类 的 属 性 及 方 法 的 确 定 : 要 从 子 类 的 角 度 来 看 子 类 间 的 共 性, 当 所 有 子 类 都 有 这 个 属 性 时, 就 应 当 考 虑 是 否 该 放 在 父 类 中, 方 法 也 是 如 此, 方 法 可 以 被 看 作 是 对 象 的 行 为, 而 类 的 方 法 这 时 这 一 类 对 象 所 共 有 的 行 为, 所 以 也 应 当 在 方 法 的 确 定 时 注 意 是 不 是 所 有 的 子 类 型 中 都 需 要 有 这 种 方 法, 并 且 会 根 据 不 同 的 类 型 的 行 为 的 方 式 也 不 同 才 可 以 覆 盖 着 个 方 法 4 java 中 方 法 的 覆 盖 子 类 中 有 和 父 类 中 可 访 问 ( 可 继 承 到 子 类 ) 的 同 名 同 返 回 类 型 同 参 数 表 的 方 法, 就 会 覆 盖 从 父 类 继 承 来 的 方 法 在 父 子 类 中, 出 现 方 法 名 相 同, 参 数 表 不 同 的 情 况, 叫 方 法 的 重 载 方 法 覆 盖 父 子 类 返 回 值 类 型 也 要 相 同 注 意 : 在 jdk1.4 以 前 要 求 方 法 的 覆 盖 时, 需 要 方 法 的 返 回 值, 参 数 表, 方 法 名 必 须 严 格 相 同, 而 在 jdk1.5 中 方 法 覆 盖, 子 类 的 中 覆 盖 的 方 法 的 返 回 值 可 以 是 父 类 中 被 覆 盖 的 方 法 的 返 回 值 类 型 的 子 类 型 注 意 : 子 类 的 方 法 覆 盖 父 类 的 方 法 时, 方 法 的 修 饰 符 要 么 相 同, 要 么 子 类 中 的 方 法 的 修 饰 符 表 示 的 访 问 权 限 要 宽 于 父 类 父 类 中 的 私 有 方 法, 不 能 被 继 承 到 子 类, 就 是 说 子 类 中 即 使 将 其 覆 盖 了 也 不 会 有 多 态 注 意 : 父 子 类 中 有 同 名 的 属 性 不 叫 子 类 覆 盖 了 父 类 的 属 性, 这 种 情 况 较 作 属 性 的 遮 盖 (shadow)

13 5 super 关 键 字 (1) 区 分 父 子 类 间 的 属 性 遮 盖 和 方 法 覆 盖 (2)super(), 表 示 在 子 类 的 构 造 方 法 中 调 用 父 类 的 构 造 方 法 ( 可 以 通 过 这 种 方 法 在 子 类 的 构 造 方 法 中 初 始 化 父 类 中 的 属 性 ),super() 也 只 能 出 现 在 构 造 方 法 的 第 一 句 上 super(), 在 子 类 的 构 造 方 中 指 明 构 造 父 类 时 调 用 哪 一 个 父 类 的 构 造 方 法 构 造 父 类 super, 这 里 所 表 示 的 是 一 个 父 类 的 对 象, 可 以 通 过 super 来 使 用 父 类 中 可 以 访 问 的 方 法 ( 可 以 在 父 类 中 定 义 setxxx(),getxxx() 方 法 来 访 问 父 类 中 的 私 有 属 性 ),super 可 以 屏 蔽 父 子 类 中 同 名 属 性 的 冲 突 注 意 : 在 写 类 的 时 候, 一 定 要 写 默 认 无 参 的 构 造 方 法, 如 果 一 个 构 造 方 法 的 第 一 句 既 不 是 this(), 也 不 是 super() 时, 那 么 就 会 在 这 里 隐 含 的 调 用 他 的 父 类 的 无 参 的 构 造 方 法, 即 隐 含 的 有 super() 6 创 建 对 象 的 过 程 1) 递 归 的 构 造 父 类 的 对 象, 默 认 调 用 父 类 无 参 的 构 造 方 法 super() 2) 分 配 本 类 空 间 3) 初 始 化 本 类 实 例 变 量 ( 属 性 ) 4) 调 用 本 类 的 构 造 方 法 7 java 中 的 多 态 --- 运 行 时 多 态 Animal a = new Dog(); // 引 用 类 型 可 以 是 对 象 类 型 的 父 类 对 象 类 型 引 用 类 型 客 观 类 型 主 观 类 型 以 子 类 覆 盖 了 父 类 的 方 法 为 前 提 1) 对 象 类 型 不 变 2) 只 能 对 一 个 对 象 调 用 引 用 类 型 中 定 义 的 方 法 3) 运 行 时 会 根 据 对 象 类 型 找 覆 盖 之 后 的 方 法 Animal a = new Dog(); Dog d = new Dog(); a = d; // 把 子 类 引 用 赋 值 给 父 类 引 用, 是 合 法 的 d = (Dog)a; // 把 父 类 引 用 赋 值 给 自 类 引 用, 需 要 强 转 引 用 instanceof 类 名 // 判 断 前 面 的 引 用 和 后 面 的 类 是 否 兼 容 可 以 翻 译 为 是 不 是 a instanceof Dag; //a 指 向 的 对 象 是 不 是 Dog 类 一 般 用 在 强 制 类 型 转 换 之 前, 避 免 转 换 异 常 多 态 可 以 使 代 码 变 得 更 通 用, 以 适 应 需 求 的 变 化 也 就 是 定 义 在 父 类 中 的 方 法, 可 以 在 子 类 中 有 不 同 的 实 现 将 其 覆 盖, 在 为 父 类 型 的 对 象 变 量 赋 值 相 应 需 要 功 能 的 子 类 的 对 象 实 例 可 以 屏 蔽 不 同 子 类 的 差 异

14 作 业 : 1. 设 计 一 个 形 状 类, 方 法 : 求 周 长 和 求 面 积 形 状 类 的 子 类 :Rect( 矩 形 ),Circle( 圆 形 ) Rect 类 的 子 类 :Square( 正 方 形 ) 不 同 的 子 类 会 有 不 同 的 计 算 周 长 和 面 积 的 方 法 创 建 三 个 不 同 的 形 状 对 象, 放 在 Shape 类 型 的 数 组 里, 分 别 打 印 出 每 个 对 象 的 周 长 和 面 积 2. 某 公 司 的 雇 员 分 为 以 下 若 干 类 : Employee : 这 是 所 有 员 工 总 的 父 类, 属 性 : 员 工 的 姓 名, 员 工 的 生 日 月 份 方 法 :getsalary(int month) 根 据 参 数 月 份 来 确 定 工 资, 如 果 该 月 员 工 过 生 日, 则 公 司 会 额 外 奖 励 100 元 SalariedEmployee :Employee 的 子 类, 拿 固 定 工 资 的 员 工 属 性 : 月 薪 HourlyEmployee :Employee 的 子 类, 按 小 时 拿 工 资 的 员 工, 每 月 工 作 超 出 160 小 时 的 部 分 按 照 1.5 倍 工 资 发 放 属 性 : 每 小 时 的 工 资 每 月 工 作 的 小 时 数 SalesEmployee :Employee 的 子 类, 销 售 人 员, 工 资 由 月 销 售 额 和 提 成 率 决 定 属 性 : 月 销 售 额 提 成 率 BasePlusSalesEmployee :SalesEmployee 的 子 类, 有 固 定 底 薪 的 销 售 人 员, 工 资 由 底 薪 加 上 销 售 提 成 部 分 属 性 : 底 薪 写 一 个 程 序, 把 若 干 各 种 类 型 的 员 工 放 在 一 个 Employee 数 组 里, 写 一 个 函 数, 打 印 出 某 月 每 个 员 工 的 工 资 数 额 注 意 : 要 求 把 每 个 类 都 做 成 完 全 封 装, 不 允 许 非 私 有 化 属 性 Java 第 五 天 2007 年 4 月 26 日 一 复 习 1 封 装 该 隐 藏 隐 藏, 该 公 开 的 公 开 属 性 隐 藏, 同 时 提 供 get/set 方 法 有 些 方 法 应 该 隐 藏 方 法 声 明 公 开, 实 现 隐 藏 实 现 的 改 变 对 架 构 的 影 响 最 小 2 继 承 一 般 -> 特 殊 单 继 承 : 一 个 类 最 多 只 能 有 一 个 直 接 父 类 类 之 间 可 以 形 成 树 状 关 系 根 据 访 问 权 限, 子 类 如 果 可 以 访 问 父 类 的 属 性 和 方 法, 就 能 继 承 private 私 有 不 能 继 承 default 本 类 + 同 包 同 包 子 类 可 以 继 承, 不 同 包 子 类 不 能 继 承 protected 本 类 + 同 包 + 不 同 包 子 类 可 以 继 承 public 公 开 可 以 继 承 方 法 的 覆 盖 (Override):

15 方 法 名 相 同, 参 数 表 相 同, 返 回 值 相 同, 访 问 修 饰 符 比 父 类 相 同 或 更 宽, 抛 出 的 异 常 不 能 比 父 类 更 宽 继 承 关 系 下 对 象 的 构 造 过 程 1) 递 归 的 构 造 父 类 对 象 2) 分 配 本 类 空 间 3) 初 始 化 本 类 属 性 4) 调 用 本 类 的 构 造 方 法 super: super. -> 父 类 对 象, 访 问 父 类 被 覆 盖 的 方 法 或 者 父 类 被 遮 盖 的 属 性 super() -> 用 在 构 造 方 法 时, 用 来 指 明 调 用 父 类 的 哪 个 构 造 方 法, 放 在 构 造 方 法 的 第 一 行, 默 认 调 用 父 类 无 参 构 造 方 法 3 多 态 编 译 时 多 态 : 方 法 的 重 载 运 行 时 多 态 : 子 类 对 象 当 作 父 类 对 象 来 用!!! 屏 蔽 同 一 父 类 下, 不 同 子 类 差 异 Animal a = new Dog(); 允 许 引 用 类 型 和 对 象 类 型 不 同, 但 要 求 引 用 类 型 是 对 象 类 型 的 父 类 对 象 类 型 代 表 了 对 象 自 身 客 观 的 实 际 类 型, 引 用 类 型 代 表 了 主 观 上 把 对 象 当 作 什 么 类 型 来 看 待 引 用 类 型 : 编 译 时 类 型, 主 观 类 型 对 象 类 型 : 运 行 时 类 型, 客 观 类 型 1) 对 象 运 行 时 类 型 不 变 2) 只 能 对 对 象 调 用 其 编 译 时 类 型 定 义 的 方 法 3) 运 行 时 根 据 对 象 类 型 去 匹 配 对 象 类 型 中 覆 盖 之 后 的 方 法 Super s1; Sub s2; s1=s2; s2=s1; //error, s2=(sub)s2 强 制 类 型 转 换 : 当 我 们 把 父 类 的 引 用 赋 值 给 子 类 引 用 的 时 候, 需 要 强 制 类 型 转 换 强 制 类 型 转 换 失 败 : 类 型 转 换 异 常. 为 了 避 免 类 型 转 换 异 常, 使 用 instanceof 判 断 引 用 instanceof 类 名 引 用 指 向 的 对 象 的 类 型 与 后 面 的 类 名 是 否 兼 容 多 态 的 作 用 : 通 用 编 程 我 们 可 以 把 不 同 子 类 的 对 象 都 当 作 父 类 对 象 看 待, 评 比 不 同 子 类 的 差 异 二 CARP( 组 合 / 聚 合 复 用 原 则 )

16 实 现 代 码 重 用 最 好 的 方 法 不 是 继 承 两 种 复 用 白 盒 复 用, 也 就 是 继 承 复 用, 破 坏 封 装, 父 类 中 的 可 以 被 子 类 访 问 到 的 就 可 以 被 继 承, 这 样 会 有 些 不 需 要 的 内 容 被 继 承 下 来, 所 以 这 种 方 式 不 太 好 黑 盒 复 用, 也 叫 组 合 复 用, 也 就 是 把 要 复 用 代 码 的 类 的 对 象 作 为 本 类 中 的 一 个 属 性, 然 后 再 通 过 方 法 的 委 托 来 实 现 由 选 择 的 复 用 破 坏 封 装 方 法 的 委 托 就 是 在 本 类 的 方 法 内 部 通 过 该 类 的 对 象 调 用 要 使 用 类 的 方 法, 不 注 意 : 尽 量 用 组 合 复 用 替 代 继 承 复 用 三 多 态 1 多 态 用 于 参 数, 可 以 在 方 法 的 参 数 中 传 入 其 父 类 类 型, 在 运 行 时 会 根 据 实 际 的 运 行 时 类 型 来 在 方 法 中 进 行 相 应 的 操 作 多 态 一 般 用 在 方 法 的 参 数 上 void feed(animal a){ a.eat(); 调 用 的 时 候 feed(new Dog()); // 运 行 时, 调 用 的 是 Dog 类 中 覆 盖 的 eat() 方 法 2 多 态 用 于 返 回 值, 可 以 在 方 法 的 返 回 值 类 型 上 是 用 其 实 际 返 回 值 的 父 类 型, 在 使 用 其 返 回 值 时 也 不 关 心 其 实 际 类 型 public static Animal getanimal(int type){ if (type==0) return new Dog(); else return new Cat(); 屏 蔽 子 类 差 异, 可 扩 展 ( 只 修 改 方 法 的 实 现, 不 必 修 改 方 法 的 声 明 ) 3 Animal a = new Dog(); a.age; // 访 问 属 性 是 没 有 多 态 的, 访 问 的 是 引 用 的 age 属 性 a.eat(); // 调 用 Dog 类 中 覆 盖 Animal 类 中 的 eat() 方 法, 多 态 4 Animal a = new Dog(); method(a); 运 行 结 果 调 用 参 数 是 Animal 类 对 象 的 那 个 method() 方 法 方 法 的 重 载 只 看 引 用 类 型, 跟 引 用 指 向 的 对 象 类 型 没 有 关 系 四 对 象 的 比 较 String s1 = new String("abc"); String s2 = new String("abc"); s1 == s2; -> false 判 断 两 个 引 用 是 否 指 向 同 一 对 象, 即 地 址 是 否 相 同 s1.equls(s2); -> true 判 断 两 个 引 用 指 向 的 对 象 的 内 容 是 否 相 同 练 习 :

17 ( 继 承, 多 态 ) 银 行 的 客 户 分 为 两 类, 储 蓄 账 户 (SavingAccount) 和 信 用 账 户 (CreditAccount), 区 别 在 于 储 蓄 账 户 不 允 许 透 支 而 信 用 账 户 可 以 透 支, 并 允 许 用 户 设 置 自 己 的 透 支 额 度. 注 意 :CreditAccount 需 要 多 一 个 属 性 ceiling 透 支 额 度 为 这 两 种 用 户 编 写 相 关 的 类 同 时 要 求 编 写 Bank 类, 属 性 : 1. 当 前 所 有 的 账 户 对 象 的 集 合, 存 放 在 数 组 中 2. 当 前 账 户 数 量 方 法 : 1. 用 户 开 户, 需 要 的 参 数 :id, 密 码, 密 码 确 认, 姓 名, 身 份 证 号 码, 邮 箱, 账 户 类 型, 返 回 新 创 建 的 Account 对 象 提 示 : 用 s1.equals(s2) 可 以 比 较 s1,s2 两 个 字 符 串 的 值 是 否 相 等. 账 户 类 型 是 一 个 整 数, 为 0 的 时 候 表 示 储 蓄 账 户, 为 1 的 时 候 表 示 信 用 账 户 2. 用 户 登 录, 参 数 :id, 密 码 返 回 Account 对 象 3. 用 户 存 款, 参 数 :id, 存 款 数 额, 返 回 修 改 过 的 Account 对 象 4. 用 户 取 款, 参 数 :id, 取 款 数 额, 返 回 修 改 过 的 Account 对 象 5. 设 置 透 支 额 度 参 数 :id, 新 的 额 度, 返 回 修 改 过 的 Account 对 象. 这 个 方 法 需 要 验 证 账 户 是 否 是 信 用 账 户 用 户 会 通 过 调 用 Bank 对 象 以 上 的 方 法 来 操 作 自 己 的 账 户, 请 分 析 各 个 方 法 需 要 的 参 数 另 外, 请 为 Bank 类 添 加 几 个 统 计 方 法 1. 统 计 银 行 所 有 账 户 余 额 总 数 2. 统 计 所 有 信 用 账 户 透 支 额 度 总 数 写 个 主 方 法 测 试 你 写 的 类 Java 第 六 天 2007 年 4 月 27 日 修 饰 符 一 static 修 饰 属 性, 方 法, 代 码 块 1 静 态 属 性 : 全 类 公 有, 称 为 类 变 量 那 么 这 个 属 性 就 可 以 用 类 名. 属 性 名 来 访 问 ( 共 有 的 类 变 量 与 对 象 无 关, 只 和 类 有 关 )

18 类 加 载 : 虚 拟 机 通 过 I/O 流 把 一 个 类 的 信 息 从 字 节 码 文 件 中 读 入 虚 拟 机 并 保 存 起 来 一 个 类 只 会 加 载 一 次 类 变 量, 会 在 加 载 时 自 动 初 始 化, 初 始 化 规 则 和 实 例 变 量 相 同 注 意 : 类 中 的 实 例 变 量 是 在 创 建 对 象 时 被 初 始 化 的, 被 static 修 饰 的 属 性, 也 就 是 类 变 量, 是 在 类 加 载 时 被 创 建 并 进 行 初 始 化, 类 加 载 的 过 程 是 进 行 一 次 也 就 是 类 变 量 只 会 被 创 建 一 次 2 静 态 方 法 : 使 这 个 方 法 成 为 整 个 类 所 公 有 的 方 法, 可 以 用 类 名. 方 法 名 直 接 访 问 注 意 :static 修 饰 的 方 法, 不 能 直 接 访 问 ( 可 以 通 过 组 合 方 式 访 问 ) 本 类 中 的 非 静 态 (static) 成 员 ( 包 括 方 法 和 属 性 ) 本 类 的 非 静 态 (static ) 方 法 可 以 访 问 本 类 的 静 态 成 员 ( 包 括 方 法 和 属 性 ), 可 以 调 用 静 态 方 法 静 态 方 法 要 慎 重 使 用 在 静 态 方 法 中 不 能 出 现 this 关 键 字, 因 为 这 是 针 对 对 象 而 言 的 java 中 的 main 方 法 必 须 写 成 static 的, 因 为, 在 类 加 载 时 无 法 创 建 对 象, 静 态 方 法 可 以 不 通 过 对 象 调 用 所 以 在 类 加 载 时 就 可 以 通 过 main 方 法 入 口 来 运 行 程 序 注 意 : 父 类 中 是 静 态 方 法, 子 类 中 不 能 覆 盖 为 非 静 态 方 法 在 符 合 覆 盖 规 则 的 前 提 下, 在 父 子 类 中, 父 类 中 的 静 态 方 法 可 以 被 子 类 中 的 静 态 方 法 覆 盖, 但 是 没 有 多 态 使 用 引 用 调 静 态 方 法, 相 当 于 使 用 引 用 的 类 型 去 调 用 静 态 方 法 ( 在 使 用 对 象 调 用 静 态 方 法 是 其 实 是 调 用 编 译 时 类 型 的 静 态 方 法 ) 3 初 始 代 码 块 在 定 义 属 性 的 位 置 上, 在 任 何 方 法 之 外, 定 义 一 个 代 码 块 动 态 初 始 代 码 块 : 在 初 始 化 属 性 之 前 调 用 初 始 化 代 码 块 { 静 态 初 始 代 码 块 : 在 类 加 载 时 运 行 static{ 只 被 运 行 一 次, 往 往 用 作 一 个 类 的 准 备 工 作 二 一 个 类 在 什 么 时 候 被 加 载? 时 机 ( 延 迟 加 载, 能 不 加 载 就 不 加 载 ) (1)new 一 个 对 象 的 时 候, 加 载 (2) 没 有 创 建 对 象, 访 问 类 中 静 态 成 员 ( 方 法 和 属 性 ), 加 载 (3) 声 明 一 个 类 的 引 用, 不 加 载 (4) 创 建 子 类, 先 加 载 父 类, 再 加 载 子 类 (5) 父 类 中 的 公 开 静 态 方 法, 子 类 继 承, 使 用 子 类 的 类 名 调 用 此 方 法, 加 载 父 类 class Super{ public static m(){ class Sub extends Super{ 在 主 函 数 中 运 行 以 下 代 码 :

19 延 迟 加 载 Sub.m(); // 加 载 了 父 类 之 后, 虚 拟 机 已 经 知 道 m() 方 法 的 调 用 了, 就 不 会 再 加 载 子 类, (6) 没 有 创 建 对 象, 访 问 类 中 静 态 常 量 ( 能 计 算 出 结 果 的 常 量, 在 编 译 的 时 候 会 用 计 算 出 来 的 结 果 替 换 表 达 式 ), 不 加 载 没 有 创 建 对 象, 访 问 类 中 静 态 常 量 ( 不 确 定 的 值 ), 加 载 (7)CoreJava day16 三 设 计 模 式 ( 编 程 套 路 ) GOF(Group Of Four) 四 人 帮 模 式 23 种 1 单 例 模 式 Singleton: class A{ private static A a = new A(); // 私 有 静 态 的 实 例 变 量 指 向 自 己, 在 类 加 载 时 创 建 唯 一 对 象 public static A newinstance(){ // 提 供 公 开 静 态 的 访 问 点, 回 返 唯 一 实 例 return a; private A(){ // 私 有 的 构 造 方 法, 防 止 滥 用 2 不 变 模 式 : 便 于 实 例 共 享, 减 少 对 存 储 空 间 的 消 耗 String 类 采 用 了 不 变 模 式 字 符 串 中 的 内 容 是 不 变 的 String a1 = "123"; // 系 统 会 先 去 串 池 中 找 "123", 找 到, 就 共 享 使 用 一 个, 没 找 到 就 在 串 池 中 创 建 一 个 String a2 = new String("123"); // 在 堆 空 间 中 创 建 "123" 池 化 的 思 想, 把 需 要 共 享 的 数 据 放 在 池 中 ( 节 省 空 间, 共 享 数 据 ) 只 有 String 类 可 以 用 中 的 字 面 值 创 建 对 象 在 String 类 中, 以 字 面 值 创 建 时, 会 到 串 池 空 间 中 去 查 找, 如 果 有 就 返 回 串 池 中 字 符 串 的 地 址, 并 把 这 个 地 址 付 给 对 象 变 量 如 果 没 有 则 会 在 串 池 里 创 建 一 个 字 符 串 对 象, 并 返 回 其 地 址 付 购 对 象 变 量, 当 另 一 个 以 字 面 值 创 建 对 象 时 则 会 重 复 上 述 过 程 如 果 是 new 在 堆 空 间 中 创 建 String 类 的 对 象, 则 不 会 有 上 述 的 过 程 a2=a1.intern(); // 返 回 字 符 串 在 串 池 中 的 引 用 消 极 方 面 : 字 符 串 连 接 +, 产 生 很 多 的 中 间 对 象 StringBuffer 类, 字 符 串 是 可 变 的 s.append("a"); // 连 接 字 符 串, 不 创 建 中 间 对 象

20 大 量 字 符 串 连 接 的 时 候 用 StringBuffer 取 代 String 四 final 修 饰 变 量, 方 法, 类 1 修 饰 变 量 被 fianl 修 饰 的 变 量 就 是 常 量 ( 常 量 名 大 写 ), 一 旦 赋 值 不 能 改 变 修 饰 局 部 变 量 : 修 饰 基 本 数 据 类 型 -> 变 量 的 值 不 能 改 变 修 饰 引 用 -> 引 用 只 能 指 向 固 定 的 对 象 修 饰 实 例 变 量 : 默 认 值 不 生 效, 可 以 再 赋 值 有 两 次 赋 值 机 会 : 初 始 化 变 量 的 时 候 final int a = 20; 时 赋 值,final 修 饰 符 常 和 static 修 饰 符 一 起 使 用, 避 免 浪 费 空 间 块 中 构 造 方 法 中 设 置 this.a = a; 对 于 直 接 在 初 始 化 但 是 不 能 同 时 使 用 这 两 种 方 法 在 一 个 对 象 完 成 创 建 的 时 候, 对 象 中 的 所 有 final 属 性 必 须 都 完 成 赋 值 类 变 量 可 以 是 final 的, 也 有 两 次 赋 值 机 会 : 定 义 变 量 的 时 候 就 赋 值 ; 静 态 初 始 代 码 2 修 饰 方 法 不 能 被 子 类 覆 盖 从 面 向 对 象 的 角 度 理 解, 可 以 保 持 操 作 的 稳 定 性 3 修 饰 类 不 能 被 继 承 在 树 状 单 继 承 关 系 中,final 类 是 树 叶 节 点 在 一 个 final 类 中 的 所 有 方 法, 默 认 都 是 final 的 注 意 :final, 不 能 用 来 修 饰 构 造 方 法 的 类 在 父 类 中 如 果 有 常 量 属 性, 在 子 类 中 使 用 常 量 属 性 时 是 不 会 进 行 父 类 的 类 加 载 静 态 常 量 如 果 其 值 可 以 确 定, 就 不 会 加 载 该 类, 如 果 不 能 确 定 则 会 加 载 该 常 量 所 在 class Super{ private final void m(){ class Sub extends Super{ public void m(){ // 用 final 可 以 证 明 出 private 的 方 法 不 继 承 给 子 类 // 不 是 方 法 的 覆 盖 五 abstract 抽 象 的 修 饰 类 和 方 法 1 修 饰 类 -> 抽 象 类 不 能 创 建 对 象, 可 以 声 明 引 用, 并 通 过 引 用 调 用 类 中 的 方 法

21 主 要 用 于 被 子 类 继 承 的, 可 以 用 父 类 引 用 指 向 子 类 对 象 2 修 饰 方 法 只 有 声 明, 没 有 实 现, 用 ; 代 替 { 需 要 子 类 继 承 实 现 ( 覆 盖 ) 如 果 一 个 类 中 有 抽 象 方 法, 那 么 这 个 类 必 须 是 抽 象 类 抽 象 类 中 不 一 定 有 抽 象 方 法 注 意 : 父 类 是 抽 象 类, 其 中 有 抽 象 方 法, 子 类 继 承 父 类, 必 须 把 父 类 中 的 所 有 抽 象 方 法 都 实 现 ( 覆 盖 ) 了, 子 类 才 有 创 建 对 象 的 能 力, 的 构 造 方 法 否 则 子 类 也 必 须 是 抽 象 类 抽 象 类 中 可 以 有 构 造 方 法, 是 子 类 在 构 造 子 类 对 象 时 需 要 调 用 的 父 类 ( 抽 象 类 ) 抽 象 类 的 合 理 性 : 没 有 抽 象 类 的 实 例, 只 有 抽 象 类 子 类 的 实 例 抽 象 方 法, 定 义 和 实 现 分 离 抽 象 (abstract) 方 法 代 表 了 某 种 标 准, 定 义 标 准, 定 义 功 能, 在 子 类 中 去 实 现 功 能 ( 子 类 继 承 了 父 类 并 需 要 给 出 从 父 类 继 承 的 抽 象 方 法 的 实 现 ) 方 法 一 时 间 想 不 到 怎 么 被 实 现, 或 有 意 要 子 类 去 实 现 而 定 义 某 种 标 准, 这 个 方 法 可 以 被 定 义 为 抽 象 (abstract) 六 三 个 修 饰 符 都 能 修 饰 方 法 ( 不 包 含 构 造 方 法 ) 1 构 造 方 法 在 创 建 对 象 的 时 候 使 用, 如 果 是 static, 那 么 只 会 在 加 载 类 的 时 候 调 用 一 次 构 造 方 法 不 能 被 继 承 (final), 谈 不 到 覆 盖, 更 不 会 由 子 类 实 现 (abstract) 2 final 和 abstract,private 和 abstract,static 和 abstract, 这 些 是 不 能 放 在 一 起 的 修 饰 符 因 为 abstract 修 饰 的 方 法 是 必 须 在 其 子 类 中 实 现 ( 覆 盖 ), 才 能 以 多 态 方 式 调 用, 以 上 修 饰 符 在 修 饰 方 法 时 子 类 都 覆 盖 不 了 这 个 方 法 final 是 不 可 以 覆 盖,private 是 不 能 够 继 承 到 子 类, 所 以 也 就 不 能 覆 盖 static 是 可 以 覆 盖 的, 但 是 在 调 用 时 会 调 用 编 译 时 类 型 的 方 法 ( 引 用 类 型 的 方 法 ), 因 为 调 用 的 是 父 类 的 方 法, 而 父 类 的 方 法 又 是 抽 象 的 方 法, 不 能 调 用 所 以 上 的 修 饰 符 不 能 放 在 一 起 作 业 :( 语 言 高 级 特 性, 三 个 修 饰 符 ) 1. 修 改 Account 类, 银 行 用 户 的 账 号 (id) 是 自 动 生 成 的, 初 始 值 为 , 第 一 个 开 户 的 用 户 id 为 , 第 二 个 为 , 依 此 类 推. 提 示 : 构 造 对 象 的 时 候 采 用 static 属 性 为 id 赋 值 2. 对 于 Account 类, 有 两 个 方 法, 存 款 方 法 和 取 款 方 法, 请 修 改 这 两 个 方 法. 存 款 方 法 改 为 不 允 许 子 类 修 改 取 款 方 法 根 据 不 同 的 子 类 而 不 同, 因 此, 改 为 抽 象 方 法, 在 两 个 子 类 中 分 别 实 现 3. 将 Bank 类 作 成 单 例

22 Java 第 七 天 2007 年 4 月 29 日 一 复 习 static 属 性 方 法 类 变 量 全 类 共 有 类 加 载 时 初 始 化, 类 名 访 问 静 态 方 法 类 名 调 用, 静 态 方 法 中 不 能 访 问 类 的 非 静 态 成 员, 可 以 覆 盖, 只 能 被 静 态 方 法 覆 盖, 没 有 多 态 初 始 代 码 块 类 加 载 时 运 行 类 加 载 : 一 个 类 编 译 之 后 会 形 成.class 文 件, 储 存 了 类 的 全 部 信 息 当 JVM 第 一 次 使 用 一 个 类 的 时 候, 会 根 据 ClassPath 找 到 对 应 的.class 文 件, 用 输 入 流 把 文 件 中 的 信 息 读 入 JVM 并 保 存 起 来, 这 样,JVM 就 认 识 了 这 个 类 类 加 载 时 机 : 第 一 次 用 这 个 类 的 时 候 1. 第 一 次 创 建 类 的 对 象, 会 加 载 2. 访 问 类 的 静 态 成 员, 会 加 载 3. 声 明 类 的 引 用, 不 会 加 载 4. 加 载 子 类, 必 然 先 加 载 父 类 5. 如 果 调 用 的 是 子 类 从 父 类 中 继 承 下 来 的 静 态 方 法, 只 会 加 载 父 类 6. 如 果 访 问 的 是 类 的 静 态 常 量, 如 果 在 编 译 的 时 候 能 够 确 定 这 个 常 量 的 值, 则 运 行 时 不 会 加 载, 否 则, 编 译 时 无 法 确 定 常 量 值, 那 么 运 行 时 就 会 加 载 设 计 模 式 : 单 例 模 式 用 途 : 一 个 类 只 能 有 一 个 对 象 实 现 : 会 有 一 个 静 态 的 属 性, 就 是 该 类 的 一 个 对 象 提 供 一 个 静 态 方 法, 来 获 得 这 个 唯 一 的 静 态 属 性 ( 单 例 ), 同 时 构 造 方 法 私 有 final 变 量 : 常 量, 一 旦 赋 值, 不 能 改 变, 为 属 性 常 量 赋 值 的 时 机 : 对 于 实 例 常 量, 初 始 化 或 者 构 造 方 法 中 可 以 赋 值 ; 对 于 类 常 量 (static final), 初 始 化 或 者 静 态 初 始 代 码 块 中 可 以 赋 值 方 法 : 不 能 被 覆 盖 类 : 不 能 被 继 承 所 有 方 法 默 认 都 是 final 的 abstract 方 法 : 只 有 定 义, 没 有 实 现 类 : 不 能 构 造 对 象, 但 可 以 用 来 声 明 一 个 引 用 ( 作 为 编 译 时 类 型 ) 如 果 一 个 类 有 抽 象 方 法, 这 个 类 必 须 是 抽 象 类, 如 果 一 个 类 是 抽 象 类, 不 一 定 有 抽 象 方 法 子 类 继 承 一 个 抽 象 类, 就 必 须 覆 盖 ( 实 现 ) 父 类 ( 抽 象 类 ) 中 的 所 有 抽 象 方 法, 否 则, 子 类 就 也 得 是 抽 象 类

23 抽 象 类 有 构 造 方 法, 给 子 类 继 承 通 过 abstract, 我 们 可 以 把 一 个 方 法 的 定 义 放 在 父 类, 留 给 子 类 实 现 二 接 口 接 口 是 一 种 程 序 结 构, 是 特 殊 的 抽 象 类 接 口 中 的 方 法 必 须 都 是 公 开 的 抽 象 方 法 (public abstract), 接 口 中 的 属 性 都 是 公 开 静 态 常 量 (public static final) 接 口 中 没 有 构 造 方 法 abstract class ClassA{ public static final int A = 10; public static final double B = 3.14; public abstract void m1(); public abstract void m2(); 致 interface IA{ int A = 10; double B = 3.14; void m1(); void m2(); // 与 上 面 的 抽 象 类 逻 辑 上 等 价, 编 译 之 后, 也 会 生 成 一 个 IA.class 文 件 所 以 一 个 源 文 件 中 可 以 写 多 个 接 口, 但 只 能 有 一 个 公 开 接 口, 并 且 要 与 源 文 件 的 名 字 一 接 口 可 以 继 承, 但 是 只 能 由 接 口 继 承 在 用 类 去 继 承 时 要 换 用 implements 关 键 字, 这 时 类 和 接 口 也 不 叫 做 继 承 关 系, 而 是 实 现 关 系, 但 其 实 质 也 是 继 承 一 个 类 可 以 继 承 也 只 能 继 承 另 外 一 个 类, 但 是 可 以 实 现 多 个 接 口, 其 语 法 是 在 implements 后 面 写 接 口 名, 多 个 接 口 以, 分 隔 接 口 之 间 是 可 以 多 继 承 的, 其 语 法 和 类 的 继 承 语 法 是 相 同 的 在 接 口 多 继 承 时, 在 extends 后 写 接 口 名 如 果 要 继 承 多 个 接 口, 接 口 名 以, 分 隔, 接 口 的 继 承 关 系 只 是 把 其 父 接 口 中 的 抽 象 方 法 继 承 到 子 接 口 中 要 实 现 接 口 就 必 须 实 现 接 口 中 的 所 有 方 法 一 个 类 可 以 在 继 承 一 个 类 的 同 时, 还 可 以 实 现 一 个 或 多 个 接 口 采 用 接 口 就 绕 开 了 单 继 承 限 制 class Impl extends ClassE implements IA,IB{ 接 口 类 型 也 可 以 做 为 编 译 时 类 型 使 用, 但 其 实 际 的 运 行 时 类 型 必 须 是 完 全 实 现 接 口 的 类 的 对 象 实 例, 这 样 就 使 多 态 变 得 很 灵 活 了

24 接 口 类 型 的 引 用 指 向 接 口 某 一 个 实 现 类 的 对 象 接 口 的 意 义 : 1, 接 口 可 以 实 现 多 继 承 2, 用 接 口 可 以 实 现 混 合 类 型 ( 主 类 型, 副 类 型 ),java 中 可 以 通 过 接 口 分 出 主 次 类 型 主 类 型 使 用 继 承, 副 类 型, 使 用 接 口 实 现 3, 接 口 进 一 步 深 化 了 标 准 的 思 想, 接 口 本 身 就 是 一 个 标 准, 他 起 到 了 降 低 耦 合 性 的 作 用, 接 口 可 以 使 方 法 的 定 义 和 实 现 相 分 离, 也 就 是 将 接 口 的 定 义 者 和 实 现 者 相 分 离, 接 口 也 可 以 用 于 降 低 模 块 间 或 系 统 间 的 耦 合 性 针 对 接 口 编 程 可 以 屏 蔽 不 同 实 现 间 的 差 异, 看 到 的 只 是 实 现 好 的 功 能 练 习 : 在 原 有 的 雇 员 练 习 上 修 改 代 码 : 公 司 会 给 SalariedEmployee 每 月 另 外 发 送 2000 元 加 班 费 给 BasePlueSalesEmployee 发 放 1000 元 加 班 费 改 写 原 有 的 代 码, 加 入 以 上 的 逻 辑 并 写 一 个 方 法, 打 印 出 本 月 公 司 总 共 发 放 了 多 少 加 班 费 练 习 : 验 证 歌 德 巴 赫 猜 想, 输 入 一 个 大 于 6 的 偶 数, 请 输 出 这 个 偶 数 能 被 分 解 为 哪 两 个 质 数 的 和 如 10=3+7 12=5+7 质 数 : 除 了 1 和 自 身, 不 能 被 任 何 数 整 除 的 数 要 求 : 两 个 人 一 组 合 作 完 成, 一 个 人 负 责 拆 数, 另 一 个 人 负 责 写 方 法, 判 断 一 个 数 是 不 是 质 数 接 口 : 定 义 标 准, 接 口 的 实 现 : 实 现 标 准 接 口 的 调 用 者 : 标 准 的 使 用 针 对 接 口 编 程 原 则, 也 就 是 按 照 标 准 实 现 接 口 的 定 义 者 定 义 好 了 标 准, 接 口 的 使 用 者 就 可 以 写 使 用 代 码, 接 口 的 实 现 者 写 好 实 现 之 后 把 实 现 对 象 传 入 接 口 的 使 用 者 中 他 调 用 接 口 中 方 法 也 就 是 掉 用 接 口 实 现 中 的 方 法 这 种 过 程 叫 做 接 口 的 回 调 ( 先 有 标 准 使 用 者, 后 有 标 准 实 现 者, 把 标 准 的 实 现 者 对 象 传 给 使 用 者, 再 由 使 用 者 通 过 接 口 调 用 标 准 实 现 者 的 方 法 ) 作 业 : 1 体 验 接 口 回 调 根 据 文 档 和 给 定 的 class 文 件, 实 现 接 口, 并 且 将 实 现 类 的 对 象 作 为 参 数 调 用 Match 类 中 的 match 方 法, 实 现 石 头 剪 刀 布 的 游 戏

25 2 接 口 为 SavingAccount 和 CreditAccount 各 自 添 加 一 个 子 类 LoanSavingAccount 类 : 用 户 可 以 贷 款, 不 可 以 透 支 LoanCreditAccount 类 : 用 户 可 以 贷 款, 可 以 透 支 说 明 : 贷 款 和 透 支 是 不 一 样 的, 透 支 指 的 是 账 户 余 额 小 于 0, 而 贷 款 用 户 需 要 一 个 贷 款 额 的 属 性. 在 ATM 机 上, 用 户 可 以 选 择 贷 款, 也 可 以 选 择 还 贷 款, 而 还 贷 款 就 是 要 把 账 户 余 额 上 的 资 金 转 到 贷 款 额 上 例 如 : 用 户 余 额 元, 贷 款 额 元, 用 户 可 以 选 择 还 款 5000 元, 则 用 户 余 额 变 为 5000, 贷 款 额 变 为 元. 利 用 接 口 来 抽 象 出 LoanSavingAccount 类 和 LoanCreditAccount 类 的 共 性 接 口 中 的 方 法 : requestloan: 贷 款 payloan: 还 贷 getloan: 获 取 用 户 贷 款 总 额 为 Bank 类 添 加 三 个 方 法, 贷 款 : 参 数 id, 贷 款 额, 返 回 修 改 过 的 Account 对 象 还 贷 款 : 参 数 id, 还 款 额, 返 回 修 改 过 的 Account 对 象 统 计 所 有 账 户 贷 款 的 总 数 Java 第 八 天 2007 年 5 月 8 日 一 复 习 接 口 是 个 特 殊 的 抽 象 类, 属 性 : 公 开 静 态 常 量, 方 法 : 公 开 抽 象 方 法 没 有 构 造 方 法 接 口 之 间 可 以 多 继 承, 一 个 类 在 继 承 另 外 一 个 类 的 同 时, 和 可 以 实 现 多 个 接 口 优 点 : 1 实 现 多 继 承, 不 会 破 坏 类 之 间 的 单 继 承 简 单 的 树 状 关 系 区 分 主 类 型 和 次 要 类 型 2 标 准, 解 耦 合 工 具 响 标 准 的 使 用 者 和 标 准 的 实 现 者 通 过 借 口 隔 离 开, 使 得 接 口 实 现 者 的 改 变 对 使 用 者 没 有 影 接 口 的 回 调 : 有 了 接 口 之 后, 先 有 接 口 使 用 者, 后 有 接 口 的 实 现 者, 把 接 口 实 现 者 对 象 传 给 接 口 使 用 者, 接 口 使 用 者 通 过 接 口, 调 用 接 口 实 现 这 中 的 方 法 二 Object

26 java 中 所 有 的 类 的 父 类 或 直 接 或 间 接 的 或 隐 含 的 都 是 Object 类 java 不 允 许 循 环 继 承, 也 就 是 互 相 继 承 是 不 可 以 的 主 要 方 法 : (1)finalize(): 对 象 被 垃 圾 收 集 的 时 候 最 后 调 用 的 方 法 不 能 把 释 放 资 源 的 代 码 写 在 其 中, 程 序 员 不 能 控 制 调 用 时 机 (2)equals(): 对 象 内 容 的 比 较 Object 类 中 的 boolean equals(object o) 方 法 是 用 来 比 较 对 象 的 内 容 是 否 相 等, 其 返 回 值 是 boolean 类 型 的 值, 相 同 为 真, 不 同 则 为 假 实 际 上 还 是 比 较 对 象 地 址 是 否 相 同 String 类 覆 盖 了 equals() 方 法, 他 比 较 是 对 象 中 的 内 容 是 否 相 同 子 类 中 也 推 荐 覆 盖 Object 类 中 继 承 的 equals() 方 法, 自 己 制 定 比 较 规 则 自 反 性 :s.equals(s) true 对 称 性 :s1.equals(s2) true s2.equals(s1) true 传 递 性 :s1.equals(s2) true s2.equals(s3) true 则 s1.equals(s3) true 覆 盖 equals() 方 法 的 步 骤 boolean equals(object o){ if(this==o) return true;//1, 看 看 是 不 是 一 个 对 象 if(o==null) return true;//2, 看 看 对 象 是 不 是 空 if(!(o instanceof 本 类 类 名 )) return false;// 看 看 是 不 是 本 类 对 象...// 根 据 本 类 设 计 (3)toString(): 返 回 对 象 的 字 符 串 表 现 形 式 Object 类 中 的 tostring() 方 法 他 返 回 的 是 类 名 加 上 他 的 地 址 的 一 个 字 符 串 在 子 类 中 推 荐 覆 盖 tostring() 方 法 System.out.println(person); 实 际 上 打 印 的 是 person 对 象 tostring 方 法 的 返 回 值. 练 习 : Employe 类 属 性 :name,age,salary 把 equals().tostring() 方 法 覆 盖 三 封 装 类 JAVA 为 每 一 个 简 单 数 据 类 型 提 供 了 一 个 封 装 类, 使 每 个 简 单 数 据 类 型 可 以 被 Object 来 装 载 除 了 int(integer) 和 char(character), 其 余 类 型 首 字 母 大 写 即 成 封 装 类 类 型 名 转 换 字 符 的 方 式 : int I=10; String s=i+ ;

27 String s1=string.valueof(i); Int I=10; Interger I_class=new integer(i); 封 装 类. 字 符 串. 基 本 类 型 int (integer(x.tostring)) >integer String (Integer.valueOf() ) >Integer Integer (x.toString() ) >String int (100+ ) >String String (Integer.parseInt() ) >int Integer (Integer.intValue() ) >int 四 异 常 帮 错 误 发 生 的 时 候 减 少 损 失, 提 高 容 错 性 1 常 的 分 类 Throwable 有 两 个 子 类 :Error 和 Exception 一 个 Error 对 象 表 示 一 个 程 序 错 误, 指 的 是 底 层 的 低 级 的 不 可 恢 复 的 严 重 错 误 此 时 程 序 一 定 会 退 出, 因 为 已 经 失 去 了 运 行 所 必 须 的 物 理 环 境 对 于 Error 错 误 我 们 无 法 进 行 处 理, 因 为 我 们 是 通 过 程 序 来 应 对 错 误, 可 是 程 序 已 经 退 出 了 我 们 可 以 处 理 的 Throwable 类 中 只 有 Exception 类 的 对 象 ( 例 外 / 异 常 ) Error Throwable RuntimeException 未 检 查 异 常 Exception 由 于 程 序 员 疏 忽 造 成 的 可 避 免 的 可 处 理, 可 不 处 理 非 Runtime 异 常 已 检 查 异 常 不 可 避 免 的 必 须 处 理 2 异 常 的 产 生 和 传 递 throw new 一 个 异 常 对 象 ; --- 表 示 抛 出 一 个 异 常 throw new NullPointerException(); 相 当 于 return, 函 数 返 回 上 一 级 传 递 :

28 沿 着 方 法 调 用 链 反 向 传 递! 当 一 个 方 法 中 出 现 异 常, 而 没 有 作 处 理, 则 以 异 常 对 象 为 返 回 值 返 回 调 用 处 ( 逐 级 传 递 ) 异 常 返 回 给 虚 拟 机 时, 虚 拟 机 终 止 退 出, 程 序 结 束 3 异 常 的 处 理 (1) 声 明 抛 出 是 方 法 声 明 的 第 五 部 分 throws+ 异 常 名 字 ( 多 个 异 常 用, 分 隔 ) 出 现 异 常, 不 处 理, 抛 给 上 一 级 处 理 并 且 子 类 抛 出 异 常 的 范 围 不 能 比 父 类 抛 出 异 常 的 范 围 更 宽 (2) 捕 获 异 常 try - catch 代 码 try - catch - finally try - finally 以 上 语 句 可 以 嵌 套 // 不 捕 获 异 常, 当 异 常 发 生, 返 回 上 一 级 之 前, 要 运 行 finally 中 的 返 回 类 型 方 法 名 ( 参 数 ){ try{ 可 能 出 错 语 句 正 常 语 句 catch( 异 常 类 e){ 对 异 常 的 处 理 正 常 语 句 // 某 种 异 常 的 引 用 捕 获 多 个 异 常 : 程 序 任 何 时 刻 只 发 生 一 个 异 常 可 对 产 生 的 每 个 异 常 分 别 捕 捉, 也 可 由 同 一 异 常 进 行 处 理, 前 提 是 这 个 共 用 的 异 常 应 该 是 所 有 这 些 该 被 捕 获 的 异 常 的 父 类, 但 是, 对 于 非 受 查 异 常 不 成 立 当 try 后 面 有 多 个 语 句 块 时, 注 意 catch 异 常 的 顺 序, 子 类 必 须 放 在 父 类 的 前 面 finally 关 键 字 无 论 异 常 是 否 发 生, 一 定 会 执 行 的 代 码, 可 放 在 finally 块 内 要 点 : 没 有 异 常 产 生 时 : 正 常 执 行 try{catch(){ > 进 入 finally 语 句 块 > 方 法 中 剩 余 代 码 中 剩 余 代 码 有 异 常 产 生 时 ( 捕 找 到 ) > 进 入 catch 处 理 > 进 入 finally 语 句 块 > 方 法 有 异 常 产 生 时 ( 没 捕 找 到 ) > 进 入 finally 语 句 块 > 离 开 方 法 一 般 写 一 些 释 放 资 源 的 代 码 在 try - catch 块 中 遇 到 System.exit(0); 则 不 会 执 行 finally 中 的 代 码 Throwable 有 一 个 message 属 性 在 使 用 catch 的 时 候 可 以 调 用 : Catch(IOException e){system.out.println(e.getmessage()); // 打 印 出 来 的 是 创 建

29 (throw new) 异 常 对 象 的 时 候, 给 定 的 参 数 Catch(IOException e){e.printstacktrace(); // 打 印 堆 栈 追 踪 信 息 以 上 两 条 语 句 都 是 可 以 打 印 出 错 的 过 程 信 息 告 诉 我 们 出 错 类 型 所 历 经 的 过 程, 在 调 试 的 中 非 常 有 用 开 发 中 的 两 个 道 理 : 1 如 何 控 制 try 的 范 围 : 根 据 操 作 的 连 动 性 和 相 关 性, 如 果 前 面 的 程 序 代 码 块 抛 出 的 错 误 影 响 了 后 面 程 序 代 码 的 运 行, 那 么 这 个 我 们 就 说 这 两 个 程 序 代 码 存 在 关 联, 应 该 放 在 同 一 个 try 中 2 对 已 经 查 出 来 的 例 外, 有 throw( 消 极 ) 和 try catch( 积 极 ) 两 种 处 理 方 法 对 于 throws 把 异 常 抛 到 try catch 能 够 很 好 地 处 理 异 常 的 位 置 ( 即 放 在 具 备 对 异 常 进 行 处 理 的 能 力 的 位 置 ) 如 果 没 有 处 理 能 力 就 继 续 上 抛 4 自 定 义 异 常 (1) 继 承 Exception 类 (2) 构 造 方 法 : 不 带 参 数 的 构 造 方 法 带 参 数 的 构 造 方 法 : 参 数 指 出 错 误 性 质,super(message); 把 参 数 传 递 给 父 类 构 造 异 常 作 业 (1) 为 Account 类 及 其 子 类 添 加 tostring 方 法 和 equals 方 法 (2)(Exception) 为 BAM 添 加 几 个 异 常 类 BalanceNotEnoughException : 用 于 取 钱 的 时 候 余 额 不 足 的 情 况 ( 包 括 账 户 余 额 超 过 透 支 额 的 情 况 ) RegisterException: 用 于 开 户 异 常 的 情 况, 例 如 密 码 两 次 输 入 不 一 致 等 情 况 LoginException: 用 户 登 录 异 常 的 情 况, 例 如 id 错 误, 密 码 错 误 LoanException: 贷 款 额 不 能 为 负 数, 如 果 用 户 试 图 将 贷 款 额 置 为 负 数, 则 会 抛 出 这 个 异 常 以 上 四 个 异 常 类 有 一 个 共 同 的 父 类 BusinessException 并 妥 善 的 处 理 这 些 异 常 Java 第 九 天 2007 年 5 月 9 日 一 复 习 1 Object 所 有 的 类 直 接 或 间 接 的 父 类 finalize: 垃 圾 收 集 的 时 候 调 用 2 包 装 类 tostring: 返 回 对 象 的 字 符 串 形 式 equals: 判 断 两 个 对 象 内 容 是 否 相 同

30 8 种 基 本 类 型 各 自 提 供 了 对 象 形 式 3 异 常 处 理 提 高 容 错 性 异 常 的 分 类 :Throwable 可 避 免 的 ) Error : 错 误, 不 可 避 免, 不 可 处 理 Exception:Runtime: 未 检 查 : 可 处 理 可 不 处 理, 首 先 应 该 努 力 避 免 异 常 ( 本 非 Runtime: 已 检 查 : 必 须 要 处 理 异 常 对 象 的 产 生 :throw 抛 出 异 常, 沿 着 方 法 调 用 链 反 向 传 递 异 常 处 理 :throws 消 极, 声 明 抛 出 try-catch 捕 获 异 常 try-catch-finally try-finally 方 法 覆 盖 : 子 类 覆 盖 方 法 不 能 比 父 类 被 覆 盖 方 法 抛 出 更 多 的, 范 围 更 宽 的 异 常 4 自 定 义 异 常 二 断 言 在 JDK1.4 之 后 开 始 出 现, 是 一 个 调 试 工 具 其 后 跟 的 是 布 尔 类 型 的 表 达 式, 如 果 表 达 式 结 果 为 真 不 影 响 程 序 运 行 如 果 为 假 系 统 出 现 低 级 错 误 (Error), 在 屏 幕 上 出 现 assert 信 息 assert a%2==0; 编 译 器 的 默 认 设 置 : 把 断 言 语 句 忽 律 javac -source 1.4 源 文 件 名 java -enableassert(-ea) 类 名 // 表 示 用 1.4 新 特 性 编 译 // 打 开 断 言 功 能 assert a%2==0:"a 必 须 是 偶 数 "; // 出 现 错 误 时 的 提 示 信 息 assert 只 是 用 于 调 试 在 产 品 编 译 完 成 后 上 线 assert 代 码 就 被 删 除 了 三 内 部 类 内 部 类 也 就 是 定 义 在 类 内 部 的 类 是 编 译 时 语 法 内 部 类 的 分 类 : 成 员 内 部 类 局 部 内 部 类 静 态 内 部 类 匿 名 内 部 类 ( 图 形 监 听 时 要 用 到, 要 掌 握 ) 1 成 员 内 部 类 四 个 访 问 权 限 修 饰 符 都 可 以 修 饰 成 员 内 部 类 内 部 类 和 外 部 类 在 编 译 时 是 不 同 的 两 个 类, 内 部 类 对 外 部 类 没 有 任 何 依 赖 内 部 类 是 一 种 编 译 时 语 法, 在 编 译 时 生 成 的 各 自 的 字 节 码 文 件 (Outer.class 和 Outer$Inner.class), 内 部 类 和 外 部 类 没 有 关 系 内 部 类 中 可 以 访 问 外 部 类 的 私 有 成 员 ( 与 C++ 的 友 员 相 比, 不 破 坏 封 装 )

31 作 为 外 部 类 的 一 个 成 员 存 在, 与 外 部 类 的 属 性 方 法 并 列 内 部 类 和 外 部 类 的 实 例 变 量 可 以 共 存 在 内 部 类 中 访 问 实 例 变 量 :this. 属 性 在 内 部 类 访 问 外 部 类 的 实 例 变 量 : 外 部 类 名.this. 属 性 在 外 部 类 的 外 部 访 问 内 部 类, 使 用 out.inner. 成 员 内 部 类 的 特 点 : (1) 内 部 类 作 为 外 部 类 的 成 员, 可 以 访 问 外 部 类 的 私 有 成 员 或 属 性 ( 即 使 将 外 部 类 声 明 为 private, 但 是 对 于 处 于 其 内 部 的 内 部 类 还 是 可 见 的 ) (2) 用 内 部 类 定 义 在 外 部 类 中 不 可 访 问 的 属 性 这 样 就 在 外 部 类 中 实 现 了 比 外 部 类 的 private 还 要 小 的 访 问 权 限 注 意 : 内 部 类 是 一 个 编 译 时 的 概 念, 一 旦 编 译 成 功, 就 会 成 为 完 全 不 同 的 两 类 对 于 一 个 名 为 outer 的 外 部 类 和 其 内 部 定 义 的 名 为 inner 的 内 部 类 编 译 完 成 后 出 现 outer.class 和 outer$inner.class 两 类 (3) 成 员 内 部 类 不 能 含 有 静 态 成 员 *** 建 立 内 部 类 对 象 时 应 注 意 : 在 外 部 类 的 内 部 可 以 直 接 使 用 inner s=new inner();( 因 为 外 部 类 知 道 inner 是 哪 个 类, 所 以 可 以 生 成 对 象 ) 而 在 外 部 类 的 外 部, 要 生 成 (new) 一 个 内 部 类 对 象, 需 要 首 先 建 立 一 个 外 部 类 对 象 ( 外 部 类 可 用 ), 然 后 在 生 成 一 个 内 部 类 对 象 内 部 类 的 类 名 是 外 部 类 类 名. 内 部 类 类 名 Outer o=new Outer(); Outer.Inner in=o.new.inner() 2 静 态 内 部 类 ( 注 意 : 前 三 种 内 部 类 与 变 量 类 似, 所 以 可 以 对 照 参 考 变 量 ) 静 态 内 部 类 定 义 在 类 中, 任 何 方 法 外, 用 static class 定 义 静 态 内 部 类 只 能 访 问 外 部 类 的 静 态 成 员 生 成 (new) 一 个 静 态 内 部 类 对 象 不 需 要 外 部 类 对 象 : 这 是 静 态 内 部 类 和 成 员 内 部 类 的 区 别 静 态 内 部 类 的 对 象 可 以 直 接 生 成 : Outer.Inner in=new Outer.Inner(); 而 不 需 要 通 过 生 成 外 部 类 对 象 来 生 成 这 样 实 际 上 使 静 态 内 部 类 成 为 了 一 个 顶 级 类 静 态 内 部 类 不 可 用 private 来 进 行 定 义 3 局 部 内 部 类 在 方 法 中 定 义 的 内 部 类 称 为 局 部 内 部 类 与 局 部 变 量 类 似, 在 局 部 内 部 类 前 不 加 修 饰 符 public 和 private, 其 范 围 为 定 义 它 的 代 码 块 注 意 : 局 部 内 部 类 不 仅 可 以 访 问 外 部 类 私 有 实 例 变 量, 还 可 以 访 问 外 部 类 的 局 部 常 量 ( 也 就 是 局 部 变 量 必 须 为 final 的 )

32 在 类 外 不 可 直 接 访 问 局 部 内 部 类 ( 保 证 局 部 内 部 类 对 外 是 不 可 见 的 ) 在 方 法 中 才 能 调 用 其 局 部 内 部 类 通 过 内 部 类 和 接 口 达 到 一 个 强 制 的 弱 耦 合, 用 局 部 内 部 类 来 实 现 接 口, 并 在 方 法 中 返 回 接 口 类 型, 使 局 部 内 部 类 不 可 见, 屏 蔽 实 现 类 的 可 见 性 4 匿 名 内 部 类 匿 名 内 部 类 是 一 种 特 殊 的 局 部 内 部 类, 它 是 通 过 匿 名 类 实 现 接 口, 并 只 创 建 一 次 匿 名 内 部 类 的 特 点 : (1) 一 个 类 用 于 继 承 其 他 类 或 是 实 现 接 口, 并 不 需 要 增 加 额 外 的 方 法, 只 是 对 继 承 方 法 的 事 先 或 是 覆 盖 (2) 只 是 为 了 获 得 一 个 对 象 实 例, 不 许 要 知 道 其 实 际 类 型 (3) 类 名 没 有 意 义, 也 就 是 不 需 要 使 用 到 注 : 一 个 匿 名 内 部 类 一 定 是 在 new 的 后 面, 用 其 隐 含 实 现 一 个 接 口 或 实 现 一 个 类, 没 有 类 名, 根 据 多 态, 我 们 使 用 其 父 类 名 因 其 为 局 部 内 部 类, 那 么 局 部 内 部 类 的 所 有 限 制 都 对 其 生 效 匿 名 内 部 类 是 唯 一 一 种 无 构 造 方 法 类 大 部 分 匿 名 内 部 类 是 用 于 接 口 回 调 用 的 匿 名 内 部 类 在 编 译 的 时 候 由 系 统 自 动 起 名 Out$1.class 如 果 一 个 对 象 编 译 时 的 类 型 是 接 口, 那 么 其 运 行 的 类 型 为 实 现 这 个 接 口 的 类 因 匿 名 内 部 类 无 构 造 方 法, 所 以 其 使 用 范 围 非 常 的 有 限 当 需 要 多 个 对 象 时 使 用 局 部 内 部 类, 因 此 局 部 内 部 类 的 应 用 相 对 比 较 多 匿 名 内 部 类 中 不 能 定 义 构 造 方 法 匿 名 内 部 类 的 写 法 : interface A{ class B{ void ia(); public A bc(){ return new A(){ ; 使 用 匿 名 内 部 类 : B b=new B(); A a=b.bc(); a.ia(); void ia(){ // 匿 名 类 实 现 了 A 接 口 注 意 : 当 类 与 接 口 ( 或 者 是 接 口 与 接 口 ) 发 生 方 法 命 名 冲 突 的 时 候, 此 时 必 须 使 用 内 部 类 来 实 现

33 用 接 口 不 能 完 全 地 实 现 多 继 承, 用 接 口 配 合 内 部 类 才 能 实 现 真 正 的 多 继 承 对 于 两 个 类, 拥 有 相 同 的 方 法 : class People { run(); interface Machine{ run(); 此 时 有 一 个 robot 类 : class Robot extends People implement Machine. 名 为 run() 的 方 法 有 2 个, 不 可 直 接 实 现 interface Machine{ void run(); class Person{ void run(){system.out.println("run"); class Robot extends People{ class Heart implements Machine{ public void run(){ System.out.println(" 发 动 机 运 行 "); public Machine getheart(){ return new Heart(); public void run(){ System.out.println(" 机 器 人 跑 "); public class Test{ public static void main(string[] args){ Robot r=new Robot(); r.run(); r.getheart().run(); 练 习 : 把 前 面 石 头 剪 刀 布 的 游 戏 改 写 为 : 采 用 匿 名 内 部 类 来 实 现 接 口, 并 获 得 对 象 去 调 用 match 方 法

34 四 集 合 集 合 ( 集 合 类 的 对 象 ) 是 用 来 管 理 其 他 若 干 对 象 的 集 合 中 保 存 的 是 对 象 的 引 用, 数 组 是 最 基 本 的 集 合 集 合 框 架 1, 接 口 集 合 中 用 到 的 类, 接 口 在 java.util 包 中, 在 使 用 时 注 意 将 其 引 入 import Collection 用 来 管 理 多 个 对 象, 集 合 中 的 每 个 元 素 都 是 对 象 1)List 一 个 List 的 实 现 类 的 对 象 在 管 理 多 个 对 象 时 会 按 顺 序 组 织 对 象 ( 即 按 照 将 对 象 放 入 的 顺 序 存 储 ) List 实 现 类 的 对 象 是 有 顺 序 的, List 实 现 类 对 象 中 的 内 容 是 可 重 复 的 ( 注 意, 顺 序 和 排 序 的 区 别 ) 2)Set 一 个 Set 的 实 现 类 表 示 一 个 数 学 概 念 上 的 集 合,Set 的 实 现 类 的 对 象 中 的 元 素 是 无 顺 序 的, 也 就 是 不 会 按 照 输 入 顺 序 来 存 放,Set 的 实 现 类 对 象 中 的 元 素 是 不 重 复 的 3)SortedSet, 他 是 Set 的 子 接 口, 他 的 实 现 类 会 对 集 合 中 的 元 素 进 行 排 序 但 是 要 指 定 排 序 规 则, 他 会 按 排 序 规 则 进 行 排 序 Map,Map 中 没 有 对 象, 而 是 键 值 对, 由 Key,value 组 成 的 键 值 对 Key 是 没 有 顺 序, 不 可 重 复 的 value 是 可 以 相 同 的, 一 个 Key 和 一 个 value 一 一 对 应 Map 接 口 ( 以 下 介 绍 其 子 接 口 ) SortedMap, 这 个 接 口 的 实 现 类 同 样 可 以 实 现, 不 过 是 对 键 值 对 中 的 Key 进 行 排 序, 这 个 接 口 的 实 现 类 也 是 要 指 定 排 序 规 则 的 1> ArrayList 是 接 近 于 功 能 的 集 合 类,ArryList 的 实 质 就 是 一 个 会 自 动 增 长 的 数 组,ArrayList 是 用 封 装 的 数 组 来 实 现 的 List 接 口 的 Collection 的 实 现 类 对 象 的 遍 历 方 式 是 用 迭 代 来 实 现 的 在 使 用 迭 代 器 时 先 要 获 得 一 个 迭 代 器 的 对 象,Iterator( 迭 代 器 接 口 ) 这 是 一 个 接 口, 迭 代 器 是 在 集 合 类 中 实 现 的, 也 就 是 说, 他 是 一 个 内 部 类 ( 匿 名 内 部 类 ) 实 现 的 Iterator 接 口 中 定 义 的 常 用 方 法 方 法 hasnext(),next() hasnext(), 这 个 方 法 会 使 用 一 个 游 标, 并 通 过 判 断 游 标 指 向 的 位 置 是 否 存 放 有 对 象 next() 方 法 也 是 Iterator 接 口 中 定 义 好 的 方 法, 这 个 方 法 会 使 游 标 指 向 下 一 个 元 素 的 位 置, 游 标 会 跳 过 第 一 个 元 素, 并 返 回 其 中 的 内 容 Collections 这 是 一 个 工 具 类, 也 是 java.util 包 中 的, 这 个 类 中 的 sort(list 接 口 的 实 现 类 的 对 象 ) 方 法, 其 参 数 是 一 个 集 合 类 的 对 象, 这 个 方 法 使 用 来 对 集 合 类 的 对 象 进 行 排 序 的 以 后, 我 将 以 集 合 这 个 名 字 来 称 呼 集 合 类 的 对 象, 对 于 字 符 串 对 象 内 容 的 集 合 来 说 会 按 字 典 顺 序 排 序 ( 升 序 ), 对 于 数 字 内 容 的 集 合 排 序 也 会 按 照 升 序 排 序 排 序 可 分 为 两 部 分 内 容, 一 个 是 排 序 的 规 则, 也 就 是 按 照 什 么 来 进 行 排 序, 并 且 排 成 什 么 样

35 的 顺 序 第 二 个 就 是 排 序 的 算 法, 他 决 定 了 排 序 的 效 率 在 对 自 定 义 的 集 合 内 容 排 序 时, 需 要 先 定 义 那 个 类 型 的 排 序 规 则 Comparable 接 口, 这 个 接 口 中 只 定 义 了 一 个 compareto(object o), 方 法 的 返 回 类 型 是 整 型, 如 果 当 前 对 象 大 于 参 数 对 象 就 返 回 正 数, 当 前 对 象 等 于 参 数 对 象 是 就 返 回 0, 当 前 对 象 小 于 参 数 对 象 时 就 返 回 负 值, 这 样 写 就 是 升 序 排 列, 反 之 则 是 进 行 降 序 排 列, 在 实 现 这 个 接 口 中 的 方 法 时, 返 回 值 定 义 方 式, 只 有 这 两 种 根 据 指 定 类 型 的 排 序 规 则 实 现 了 Comparable 接 口, 那 么 就 可 以 对 存 有 这 个 类 型 的 集 合 进 行 整 体 排 序 Comparable 接 口, 也 叫 做 可 比 较 接 口 这 个 接 口 在 java.lang 包 下 只 要 实 现 了 这 个 接 口, 就 是 可 排 序 的 接 下 来 介 绍 另 外 一 种 对 自 定 义 类 型 对 象 的 集 合 整 体 排 序 的 方 法, 也 就 是 实 现 比 较 器 接 口 (Comparator), 这 个 接 口 中 定 义 了 一 个 compare(object o1,object o2) 方 法 来 比 较 两 个 对 象, 这 个 方 法 的 返 回 值 定 义 和 上 面 介 绍 的 那 个 方 法 是 一 样 注 意 : 在 API, 帮 助 文 档 中 以 上 两 个 方 法 的 参 数 类 型 是 T, 这 代 表 的 模 板 类 型, 也 就 是 集 合 中 存 放 的 内 容 的 类 型, 在 JDK1.4 中 其 参 数 就 是 Object 类 型, 模 板 类 型 的 详 细 内 容 会 在 最 后 的 JDK5.0 新 特 性 中 讲 到 Comparator 接 口 可 以 在 匿 名 内 部 类 中 实 现,Collections 中 的 sort( 集 合 了 的 对 象, 比 较 器 ) 方 法, 可 以 对 自 定 义 类 型 内 容 的 集 合 进 行 整 体 排 序 2> LinkedList, 它 是 List 接 口 的 实 现 类, 其 底 层 是 用 双 向 循 环 链 表 来 实 现 的 注 意 :ArrayList 的 查 询 效 率 比 较 高, 增 删 动 作 的 效 率 比 较 差, 适 用 于 查 询 比 较 频 繁, 增 删 动 作 较 少 的 元 素 管 理 的 集 合 LinkedList 的 查 询 效 率 低, 但 是 增 删 效 率 很 高 适 用 于 增 删 动 作 的 比 较 频 繁, 查 询 次 数 较 少 的 元 素 管 理 集 合 ArrayList,LinkedList 都 是 线 程 不 安 全 的 实 现 堆 栈 1, 数 组 (ArrayList, 增 删 效 率 比 较 低, 不 适 合 ) 2,LinkedList( 实 现 堆 栈 的 好 方 法 ) 3,java.util.Stack 类,Stack 是 Vector 的 子 类,Vector 类 是 一 个 线 程 安 全 的 ( 是 一 个 重 量 级 的 类 ), 并 继 承 了 Vector 的 方 法,Verctor 类 ( 这 个 类 也 是 List 接 口 的 实 现 类 ) 和 ArrayList 的 功 能 近 乎 相 同 ( 不 推 荐 使 用 Stack 类 来 实 现 堆 栈 ) CoreJava 第 十 天 2007 年 5 月 10 日

36 一 复 习 内 部 类 1 成 员 内 部 类 可 以 访 问 外 部 类 的 私 有 成 员, 外 部 类 类 名.this. 属 性 构 造 成 员 内 部 类 对 象, 必 须 先 构 造 一 个 外 部 类 对 象, 外 部 类 对 象.new 构 造 内 部 类 对 象 2 静 态 内 部 类 只 能 访 问 外 部 类 的 静 态 成 员 构 造 静 态 内 部 类 对 象 时, 不 再 需 要 构 造 外 部 类 对 象 3 局 部 内 部 类 在 外 部 类 方 法 内 定 义 的 内 部 类 不 仅 能 访 问 外 部 类 的 私 有 成 员, 而 且 还 能 访 问 外 部 类 的 局 部 变 量, 但 是 要 求 局 部 变 量 是 final 的 4 匿 名 内 部 类 局 部 内 部 类, 用 于 实 现 一 个 借 口 或 者 继 承 一 个 类, 只 会 构 造 一 次 内 部 类 的 作 用 : 访 问 外 部 类 的 私 有 成 员, 不 破 坏 封 装 可 以 给 编 程 带 来 一 些 方 便 我 们 可 以 把 接 口 公 开, 把 接 口 的 实 现 类 以 内 部 类 的 形 式 隐 藏 起 来 强 制 用 户 通 过 接 口 来 实 现 弱 耦 合 接 口 + 内 部 类 实 现 多 继 承 二 List 接 口 的 实 现 类 1 ArrayList 底 层 使 用 数 组 实 现 2 Vector ArrayList Vector 3 LinkedList 轻 量 级 快 线 程 不 安 全 重 量 级 慢 线 程 安 全 的 底 层 使 用 双 向 循 环 链 表 实 现 ArrayList 数 组 查 询 快 增 删 操 作 慢 LinkedList 链 表 查 询 慢 增 删 操 作 快 栈 使 用 组 合 复 用 实 现 栈 三 Set 接 口 1 HashSet Set 的 实 现 类 的 集 合 对 象 中 不 能 够 有 重 复 元 素,HashSet 也 一 样 是 使 用 了 一 种 标 识 来 确 定 元 素 的 不 重 复, 是 元 素 内 容 不 重 复 HashSet 用 一 种 算 法 来 保 证 集 合 中 的 元 素 是 不 重 复 的,HashSet 的 底 层 实 现 还 是 数 组 Object 类 中 的 hashcode() 的 方 法 是 所 有 子 类 都 会 继 承 这 个 方 法, 这 个 方 法 会 用 Hash 算 法 算 出 一 个 Hash( 哈 希 ) 码 值 返 回,HashSet 会 用 Hash 码 值 去 和 数 组 长 度 取 模, 模 ( 这 个 模 就 是 对 象 要 存 放 在 数 组 中 的 位 置 ) 相 同 时 才 会 判 断 数 组 中 的 元 素 和 要 加 入 的 对 象 的 内 容 是 否 相 同, 如 果 不 同 才 会 添 加 进 去 Hash 算 法 是 一 种 散 列 算 法

37 注 意 : 所 有 要 存 入 HashSet 的 集 合 对 象 中 的 自 定 义 类 必 须 覆 盖 hashcode(),equals() 两 个 方 法, 才 能 保 证 集 合 中 元 素 容 不 重 复 在 覆 盖 hashcode() 方 法 时, 要 使 相 同 对 象 的 hashcode() 方 法 返 回 相 同 值, 覆 盖 equals() 方 法 再 判 断 其 内 容 为 了 保 证 效 率, 所 以 在 覆 盖 hashcode() 方 法 时, 也 要 尽 量 使 不 同 对 象 尽 量 返 回 不 同 的 Hash 码 值 如 果 数 组 中 的 元 素 和 要 加 入 的 对 象 的 hashcode() 返 回 了 相 同 的 Hash 值 ( 相 同 对 象 返 回 相 同 整 数 ), 才 会 用 equals() 方 法 来 判 断 两 个 对 象 的 内 容 是 否 相 同 ( 不 同 对 象 返 回 不 同 整 数 ) 练 习 : 把 若 干 Employee 对 象 放 在 Set 中 并 遍 历, 要 求 没 有 重 复 元 素 2 SortedSet 接 口 是 Set 的 子 接 口 TreeSet 是 SortedSet 接 口 的 实 现 类, 他 可 以 对 集 合 中 的 元 素 进 行 排 序 要 存 放 在 TreeSet 中 自 定 义 类 的 对 象, 这 个 类 要 么 是 已 经 实 现 了 Comparable 接 口, 要 么 是 能 给 出 Comparator 比 较 器, TreeSet 可 以 自 动 过 滤 掉 重 复 元 素 所 以 不 用 重 载 hashcode() 方 法,TreeSet 会 根 据 比 较 规 则 判 断 元 素 内 容 是 否 相 同,TreeSet 会 在 元 素 存 入 时 就 进 行 了 排 序 判 断 对 象 重 复 的 依 据 :compareto() 方 法 的 返 回 值 为 0, 就 是 重 复 元 素 ( 在 TreeSet 给 出 排 序 规 则 时, 一 定 要 注 意 对 象 内 容 相 等 的 条 件, 一 定 要 注 意 在 主 观 的 认 为 两 个 对 象 内 容 相 同 时, 才 可 以 使 用 比 较 少 的 条 件 来 进 行 判 断 ) 在 要 排 序 时 才 使 用 TreeSet 类 ( 存 储 效 率 比 较 低 ),HashSet 的 存 储 效 率 比 较 高, 在 需 要 为 HashSet 的 对 象 排 序 时, 就 可 以 把 HashSet 中 的 元 素 放 入 TreeSet 四 Map Map 中 只 可 以 存 放 键 值 对 ( Key,value ), 其 中 Key 是 不 可 以 重 复 的 Key 和 value 是 一 一 对 应 的 HashMap, 是 Map 接 口 的 实 现 类,Key 时 无 序 存 放 的, 其 中 Key 是 不 可 以 重 复 的, 它 也 是 通 过 Hash 码 值 来 保 证 Key 不 重 复 的,Key 和 value 是 一 一 对 应 的 如 果 要 加 入 的 键 值 对 和 HashMap 中 键 值 对 的 Key 是 相 同 的 就 会 将 这 个 集 合 中 的 Key 所 队 应 的 value 值 进 行 覆 盖, 在 使 用 自 定 义 类 型 作 为 Key 时, 那 就 是 要 覆 盖 hashcode(),equals() 方 法, 也 就 是 和 HashSet 中 要 放 入 自 定 义 类 型 是 的 处 理 方 法 相 同 这 个 类 的 对 象 是 线 程 不 安 全 的 遍 历 :(1)vlaues() 返 回 所 有 值 (value) 的 集 合, 是 一 个 Collection (2)keySet() 返 回 所 有 键 对 象 的 集 合, 是 一 个 Set 过 遍 历 这 个 Set, 用 get() 方 法 来 获 得 Key 所 对 应 的 value, 也 就 遍 历 了 Map Hashtable, 也 是 Map 接 口 的 实 现 类, 他 和 HashMap 比 较 相 似, 只 不 过 这 个 类 对 象 是 重 量 级 的, 也 是 线 程 安 全 的 他 不 允 许 Key 和 value 为 null Properties, 这 个 类 是 Hashtable 的 子 类, 他 的 Key 和 value 只 能 是 字 符 串

38 SortedMap 是 Map 的 子 接 口 TreeMap, 是 SortedMap 的 实 现 类, 他 会 按 照 Key 进 行 排 序 和 TreeSet 类 一 样, 在 使 用 自 定 义 类 作 Key 时, 要 用 自 定 义 类 实 现 Comparable 接 口 练 习 : 达 内 希 望 在 学 生 毕 业 的 时 候 统 计 出 学 生 在 校 期 间 考 试 成 绩 的 排 名, 写 一 个 Student 类, 其 中 用 集 合 来 管 理 每 个 学 生 的 各 个 科 目 的 考 试 成 绩, 将 多 个 Student 对 象 放 在 集 合 中, 打 印 出 学 生 的 总 分 以 及 排 名 ( 集 合 ) 改 写 Bank 类, 采 用 集 合 的 方 式 来 管 理 多 个 Account 对 象 为 Bank 类 添 加 一 个 方 法 打 印 所 有 用 户 的 总 资 产 排 名 说 明 : 一 个 用 户 可 能 会 有 多 个 账 号, 以 身 份 证 号 为 准. 总 资 产 指 多 个 账 户 余 额 的 总 和, 不 需 要 考 虑 贷 款 账 户 的 贷 款 额 考 试 系 统 Exam 类 考 试 类 属 性 : 若 干 学 生 一 张 考 卷 提 示 : 学 生 采 用 HashSet 存 放 Paper 类 考 卷 类 属 性 : 若 干 试 题 提 示 : 试 题 采 用 HashMap 存 放,key 为 String, 表 示 题 号,value 为 试 题 对 象 Student 类 学 生 类 属 性 : 姓 名 一 张 答 卷 一 张 考 卷 Question 类 试 题 类 属 性 : 题 号 题 目 描 述 若 干 选 项 正 确 答 案 ( 多 选 ) 提 示 : 若 干 选 项 用 ArrayList AnswerSheet 类 答 卷 类 属 性 : 每 道 题 的 答 案 提 示 : 答 卷 中 每 道 题 的 答 案 用 HashMap 存 放,key 为 String, 表 示 题 号,value 为 学 生 的 答 案 问 题 : 为 Exam 类 添 加 一 个 方 法, 用 来 为 所 有 学 生 判 卷, 并 打 印 成 绩 排 名 ( 名 次 姓 名 )

39 CoreJava 第 十 一 天 2007 年 5 月 11 日 一 复 习 集 合 : 用 一 个 对 象 储 存 管 理 多 个 对 象 Collection: 元 素 都 是 对 象 遍 历 : 迭 代 遍 历 List: 元 素 有 顺 序, 可 以 重 复 遍 历 : 还 可 以 用 for 循 环 ( 下 标 ) 排 序 :Collections.sort(list) 实 现 类 : ArrayList: 底 层 数 组 实 现, 查 询 快, 而 增 删 慢 ; 轻 量 级, 线 程 不 安 全 Vector: 底 层 数 组 实 现, 重 量 级, 线 程 安 全 LinkedList: 底 层 链 表 实 现, 查 询 慢, 增 删 快 在 Java 中 用 LinkedList 实 现 一 个 栈, 不 用 数 组, 因 为 栈 的 主 要 功 能 就 是 增 删, 数 组 慢 ; 不 用 Vector, 因 为 效 率 低 Set: 元 素 无 序, 元 素 内 容 不 重 复 SortedSet: 按 照 各 种 排 序 规 则 给 Set 排 序 实 现 类 : HashSet: 采 用 哈 希 算 法 保 证 元 素 不 重 复, 覆 盖 hashcode() 保 证 哈 希 码 相 同,equals() 保 证 true TreeSet: 元 素 一 定 要 实 现 了 Comparable 接 口 的 根 据 排 序 规 则,compareTo() 返 回 0, 说 明 是 重 复 元 素 Map: 元 素 是 键 值 对 key 无 序, 不 重 复 value 可 以 重 复 SortedMap: 按 照 key 排 序 遍 历 :values() 遍 历 所 有 的 值 对 象 keyset() 遍 历 所 有 的 键 对 象 实 现 类 : HashMap: 线 程 不 安 全, 允 许 null 作 为 key 和 value Hashtable : 线 程 安 全, 不 允 许 TreeSet:SortedSet 的 实 现 类 二 java 中 的 图 形 界 面 GUI, 图 形 化 的 用 户 接 口, 为 了 人 机 交 互 使 用 的 BS 与 CS 的 联 系 与 区 别

40 C/S 是 Client/Server 的 缩 写 服 务 器 通 常 采 用 高 性 能 的 PC 工 作 站 或 小 型 机, 并 采 用 大 型 数 据 库 系 统, 如 Oracle Sybase Informix 或 SQL Server 客 户 端 需 要 安 装 专 用 的 客 户 端 软 件 B/S 是 Brower/Server 的 缩 写, 客 户 机 上 只 要 安 装 一 个 浏 览 器 (Browser), 如 Netscape Navigator 或 Internet Explorer, 服 务 器 安 装 Oracle Sybase Informix 或 SQL Server 等 数 据 库 在 这 种 结 构 下, 用 户 界 面 完 全 通 过 WWW 浏 览 器 实 现, 一 部 分 事 务 逻 辑 在 前 端 实 现, 但 是 主 要 事 务 逻 辑 在 服 务 器 端 实 现 浏 览 器 通 过 Web Server 同 数 据 库 进 行 数 据 交 互 C/S 与 B/S 区 别 : 1. 硬 件 环 境 不 同 : C/S 一 般 建 立 在 专 用 的 网 络 上, 小 范 围 里 的 网 络 环 境, 局 域 网 之 间 再 通 过 专 门 服 务 器 提 供 连 接 和 数 据 交 换 服 务. B/S 建 立 在 广 域 网 之 上 的, 不 必 是 专 门 的 网 络 硬 件 环 境, 例 与 电 话 上 网, 租 用 设 备. 信 息 自 己 管 理. 有 比 C/S 更 强 的 适 应 范 围, 一 般 只 要 有 操 作 系 统 和 浏 览 器 就 行 2. 对 安 全 要 求 不 同 C/S 一 般 面 向 相 对 固 定 的 用 户 群, 对 信 息 安 全 的 控 制 能 力 很 强. 一 般 高 度 机 密 的 信 息 系 统 采 用 C/S 结 构 适 宜. 可 以 通 过 B/S 发 布 部 分 可 公 开 信 息. B/S 建 立 在 广 域 网 之 上, 对 安 全 的 控 制 能 力 相 对 弱, 可 能 面 向 不 可 知 的 用 户 3. 对 程 序 架 构 不 同 C/S 程 序 可 以 更 加 注 重 流 程, 可 以 对 权 限 多 层 次 校 验, 对 系 统 运 行 速 度 可 以 较 少 考 虑. B/S 对 安 全 以 及 访 问 速 度 的 多 重 的 考 虑, 建 立 在 需 要 更 加 优 化 的 基 础 之 上. 比 C/S 有 更 高 的 要 求 B/S 结 构 的 程 序 架 构 是 发 展 的 趋 势, 从 MS 的.Net 系 列 的 BizTalk 2000 Exchange 2000 等, 成 熟. 全 面 支 持 网 络 的 构 件 搭 建 的 系 统. SUN 和 IBM 推 的 JavaBean 构 件 技 术 等, 使 B/S 更 加 4. 软 件 重 用 不 同 C/S 程 序 可 以 不 可 避 免 的 整 体 性 考 虑, 构 件 的 重 用 性 不 如 在 B/S 要 求 下 的 构 件 的 重 用 性 好. B/S 对 的 多 重 结 构, 要 求 构 件 相 对 独 立 的 功 能. 能 够 相 对 较 好 的 重 用. 就 入 买 来 的 餐 桌 可 以 再 利 用, 而 不 是 做 在 墙 上 的 石 头 桌 子 5. 系 统 维 护 不 同? C/S 程 序 由 于 整 体 性, 必 须 整 体 考 察, 处 理 出 现 的 问 题 以 及 系 统 升 级. 升 级 难. 可 能 是 再 做 一 个 全 新 的 系 统 B/S 构 件 组 成, 方 面 构 件 个 别 的 更 换, 实 现 系 统 的 无 缝 升 级. 系 统 维 护 开 销 减 到 最 小. 用 户 从 网 上 自 己 下 载 安 装 就 可 以 实 现 升 级. 6. 处 理 问 题 不 同 C/S 程 序 可 以 处 理 用 户 面 固 定, 并 且 在 相 同 区 域, 安 全 要 求 高 需 求, 与 操 作 系 统 相 关. 应 该 都 是 相 同 的 系 统 B/S 建 立 在 广 域 网 上, 面 向 不 同 的 用 户 群, 分 散 地 域, 这 是 C/S 无 法 作 到 的. 与 操 作 系 统 平 台 关 系 最 小. 7. 用 户 接 口 不 同 C/S 多 是 建 立 的 Window 平 台 上, 表 现 方 法 有 限, 对 程 序 员 普 遍 要 求 较 高 B/S 建 立 在 浏 览 器 上, 有 更 加 丰 富 和 生 动 的 表 现 方 式 与 用 户 交 流. 并 且 大 部 分 难 度 减 低, 减 低 开 发 成 本. 8. 信 息 流 不 同

41 C/S 程 序 一 般 是 典 型 的 中 央 集 权 的 机 械 式 处 理, 交 互 性 相 对 低 B/S 信 息 流 向 可 变 化, B-B B-C B-G 等 信 息 流 向 的 变 化, 更 像 交 易 中 心 构 造 图 形 界 面 的 步 骤 1, 选 择 一 个 容 器 2, 设 置 容 器 的 布 局 管 理 器 3, 向 容 器 添 加 组 件 4, 事 件 的 监 听 容 器 (Container) 用 于 管 理 其 他 的 组 件 的 对 象 组 件 必 须 放 到 容 器 里 JFrame, 这 是 一 个 最 顶 层 的 窗 体 容 器, 所 有 其 他 的 组 件 必 须 放 在 顶 层 容 器 里 JFrame frame = new JFrame("He llo Swing"); frame.setsize(500,300); frame.setvisible(true); // 创 建 窗 体, 字 符 串 为 窗 体 的 标 题 // 设 置 窗 口 大 小,500 像 素 长,300 像 素 高 // 设 置 可 见 性 JPanel, 他 不 是 顶 层 容 器, 必 须 放 在 顶 层 容 器 中, 任 何 一 个 容 器 都 有 add() 方 法,Panel 面 板 是 透 明 的 ( 默 认 ) 他 也 是 一 个 组 件 JDialog 对 话 框 容 器, 他 要 依 附 于 其 父 组 件, 他 不 是 一 个 顶 层 容 器 布 局 管 理 : 对 于 任 何 一 个 容 器 类 中 都 有 setlayout() 方 法, 用 容 器 对 象 调 用 这 个 方 法, 来 设 置 容 器 的 布 局 管 理 器 (LayoutManage r 这 是 一 个 接 口, 所 有 布 局 管 理 器 都 实 现 了 这 个 接 口 ) 可 用 的 布 局 管 理 器 : 所 有 的 布 局 管 理 器 实 现 了 一 个 接 口 java.awt.layoutmanager FlowLayout, 流 式 布 局 管 尝 试 在 一 行 中 按 增 加 顺 序 摆 放 组 件, 窗 体 大 小 改 变 时, 组 件 位 置 会 相 应 发 生 改 变 Panel 的 默 认 布 局 管 理 就 是 FlowLayout FlowLayout flow = new FlowLayout(); frame.setlayout(flow); BorderLayout, 按 方 位 进 行 布 局 管 理,(North,South,East,West,Middle) 不 明 确 指 定, 就 会 默 认 加 载 在 中 间 (Middle), 每 个 部 分 只 能 放 一 个 组 件 frame.add(component comp,string place); 这 个 方 法 是 在 指 定 的 位 置 添 加 组 件 JFrame 的 默 认 布 局 管 理 器 GridLayout, 网 格 布 局, 通 过 行 列, 间 距, 来 用 网 格 分 割, 把 组 件 放 入 如 网 格 中, 先 行 后 列 摆 放 组 件 可 以 保 证 每 个 组 件 的 大 小 都 是 一 样 的 frame.setlayout(new GirdLayout(3,2)); // 把 容 器 平 均 的 分 为 3 行 2 列, 先 左 后 右, 先 上 到 下 的 顺 序 排 列 CardLayout, 卡 片 布 局, 组 件 重 叠 放 置 GridBagLayout, 组 件 可 以 跨 行 跨 列 的 网 格 布 局 *** 注 意 : 一 定 要 在 图 形 界 面 都 其 他 功 能 都 设 置 好 之 后 才 能 设 置 可 见 性 JButton : 按 钮 JTextField: 单 行 文 本 域

42 JTextArea: 多 行 文 本 区 JPasswordField: 密 码 输 入 框 JScrollPane: 滚 动 窗 体 使 用 一 个 多 行 文 本 域 作 为 参 数 创 建 滚 动 窗 体 JComboBox: 下 拉 选 择 框 JRadioButton: 单 选 按 钮 JCheckBox : 多 选 按 钮 JList: 多 行 列 表 JLabel: 标 签 JEditorPane: 显 示 结 构 化 文 档 Border: 边 框 JMenuBar: 菜 单 条 JMenu: 菜 单 JMenuItem: 菜 单 项 JPopupMenu: 弹 出 式 菜 单 JSlider: 滑 动 条 JProgressBar: 进 度 条 JTabbedPane: 分 层 面 板 JSplitPane: 分 隔 面 板 JToolBar: 工 具 条 JFileChooser: 文 件 选 择 器 JColorChooser: 颜 色 选 择 器 显 示 对 话 框 JoptionPane 里 面 有 很 多 静 态 方 法 可 以 弹 出 对 话 框 注 意 : 具 体 的 方 法 可 以 去 参 看 Java2 SE 的 API 文 档 三 awt 事 件 模 型 ( 观 察 者 模 式 )( 重 点 ) 事 件 模 型 中, 包 括 事 件 源 对 象, 事 件 处 理 者 ( 事 件 监 听 者 对 象 ), 事 件 对 象 事 件 源 和 事 件 处 理 者 之 间 建 立 了 授 权 注 册 关 系, 也 就 是 在 事 件 源 类 中 有 一 个 事 件 处 理 者 的 对 象 作 为 属 性, 也 可 能 是 一 个 事 件 处 理 者 的 集 合 事 件 对 象 事 件 源 事 件 处 理 者 这 就 是 事 件 模 型 的 机 制, 也 就 是 由 事 件 源 对 象 发 送 一 个 消 息 ( 事 件 对 象 ), 然 后 事 件 处 理 者 调 用 相 应 的 方 法 处 理 事 件

43 在 事 件 监 听 器 接 口 中 定 义 的 方 法, 都 要 以 事 件 对 象 为 参 数 *** 一 个 事 件 源 可 以 注 册 多 个 同 类 型 的 监 听 器, 也 可 以 注 册 多 种 多 个 事 件 监 听 器, 一 个 事 件 监 听 器 也 可 以 为 多 个 事 件 源 服 务 事 件 对 象 继 承 自 EventObject 类, 并 可 以 通 过 getsource() 方 法 获 得 事 件 源 对 象, 当 然 需 要 在 构 造 事 件 对 象 时 将 事 件 源 对 象 传 入, 来 区 分 是 哪 个 事 件 源 发 出 的 事 件, 所 以 要 用 事 件 对 象 作 为 参 数 事 件 源, 事 件 对 象, 监 听 接 口, 在 java.awt 包 中 提 供 了 很 多 已 经 定 义 好 的, 只 需 要 实 现 监 听 接 口 就 好 了 什 么 是 发 消 息 : A,B,C 三 个 类, 分 别 作 为 事 件 源, 事 件 处 理 者, 事 件 对 象 在 A 类 中 有 一 个 B 类 的 属 性 或 者 是 一 个 内 容 为 B 类 对 象 的 集 合, 也 就 是 事 件 源 和 事 件 处 理 者 之 间 的 建 立 了 授 权 关 系, 在 B 类 需 要 实 现 一 个 自 定 义 的 接 口, 这 个 自 定 义 的 接 口 继 承 了 EventListener,EventListener 接 口 中 没 有 定 义 任 何 方 法, 这 只 是 一 个 标 记 接 口 实 现 在 自 定 义 接 口 中 定 义 好 的 用 于 事 件 处 理 的 方 法,C 类 要 继 承 EventObject 类 这 些 方 法 是 以 事 件 对 象 为 参 数 的 b(c c), 而 后 在 A 类 a(c c) 方 法 中 使 用 B 类 的 对 象 调 用 B 类 中 的 b(c c) 方 法, 并 把 事 件 对 象 作 为 参 数, 并 在 main 方 法 中 用 A 类 的 对 象 调 用 了 a(c) 方 法, 这 也 就 叫 做 A 类 对 象 给 B 类 发 送 了 消 息 也 就 是 说 事 件 源 对 象 间 接 调 用 了 事 件 监 听 器 的 方 法, 并 以 事 件 对 象 为 实 参 传 到 事 件 监 听 器 的 方 法 中, 要 就 叫 事 件 源 给 事 件 监 听 器 的 方 法 发 了 一 个 消 息 ( 事 件 对 象 ) 例 子 如 下 : import java.util.*; // 事 件 源 类 class A{ private String test; private List li=new ArrayList(); public A(String test){ this.test=test; public String gettest(){return this.test; public void addb(b b){ this.li.add(b); public void removeb(b b){ this.li.remove(b);

44 /* * 所 谓 的 事 件 源 给 事 件 监 听 器, 发 送 事 件 对 象 * 其 实 就 是 事 件 源 用 事 件 为 参 数, 调 用 时 间 监 听 器 的 相 应 方 法 */ public void fire(){ C c=new C(this); Iterator it=li.iterator(); while(it.hasnext()){ B b=(b)it.next(); b.b(c); // 事 件 监 听 器 的 接 口, 要 继 承 EventListener 标 记 接 口 // 监 听 接 口 中 的 每 一 个 方 法, 都 应 该 以 对 应 的 时 间 对 象 作 为 参 数 interface Blistener extends EventListener{ void b(c c); // 事 件 监 听 器, 实 现 接 口 class B implements Blistener{ /* public void b(c c){ * 事 件 对 象 类 A a=(a)c.getsource(); System.out.println(a.getTest()+" "+c.getmessage()); * 事 件 对 象 类 中 要 封 装 事 件 源 对 象 */ class C extends EventObject{ private String message; public C(Object src){ super(src); public void setmessage(string message){ this.message=message; public String getmessage(){return this.message; public class Test{ public static void main(string[] args){ A a1=new A("Event"); B b1=new B();

45 c1.setmessage("test"); a1.addb(b1);// 注 册 监 听 器 a1.fire();// 发 送 事 件 以 上 代 码 只 是 事 例, 在 引 入 包 之 后 可 以 运 行 在 Java 的 图 形 编 程 中, 所 有 动 作 ( 事 件 ) 都 已 经 提 供 了 相 应 的 事 件 对 象 和 事 件 监 听 接 口, 例 如 : 实 现 窗 口 的 关 闭 按 钮, 点 击 关 闭 按 钮 会 发 出 相 应 的 事 件 对 象, 相 应 的 调 用 监 听 器 中 实 现 好 的 方 法 相 应 的 方 法 清 参 阅 Java2 SE API 帮 助 文 档 缺 省 适 配 模 式, 通 过 一 个 抽 象 类 实 现 接 口, 抽 象 类 中 的 接 口 方 法 实 现, 都 是 一 个 无 意 义 的 空 实 现, 可 以 继 承 这 个 抽 象 类, 只 覆 盖 向 覆 盖 的 方 法 就 可 以 了 在 java.awt.event 包 中, 会 有 一 些 适 配 类, 也 就 是 把 相 应 的 XXXListener, 换 成 XXXAdapter 就 是 适 配 类 在 java.awt.event 包 中 的 ActionEvent 类, 在 以 下 操 作 中 会 发 送 这 个 事 件, 1,JButton 组 件, 按 钮 被 点 击 2,JTextField 组 件, 在 单 行 文 本 域 中 按 Enter 键 3,JCheckBox 组 件, 选 中 了 复 选 框 4,JRadioButton 组 件, 选 中 了 单 选 按 钮 5,JMenu 组 件, 选 中 菜 单 项 作 业 : 写 一 个 股 市 类 作 为 事 件 源, 事 件 源 会 随 机 产 生 波 动, 写 两 个 监 听 类, 一 个 会 在 股 市 跌 的 时 候 卖 出, 涨 的 时 候 买 入, 另 一 个 投 资 逻 辑 刚 好 相 反 CoreJava 第 十 二 天 一 复 习 AWT 事 件 模 型 (Observer 模 式 ) 1 事 件 源 2 事 件 对 象 3 事 件 监 听 器 事 件 源 和 监 听 器 事 先 进 行 授 权 注 册, 当 事 件 条 件 满 足 时, 事 件 源 会 给 注 册 的 监 听 器 发 送 一 个 事 件 对 象, 由 事 件 监 听 器 作 出 相 应 的 处 理 一 个 事 件 源 可 以 是 多 种 事 件 的 事 件 源 一 个 事 件 源 就 同 一 类 事 件 可 以 注 册 多 个 监 听 器

46 一 个 监 听 器 可 以 同 时 注 册 在 多 个 事 件 源 当 中 事 件 源 和 监 听 器 是 独 立, 弱 耦 合 的, 是 各 司 其 职 的 事 件 对 象 中 会 封 装 事 件 源 对 象 事 件 监 听 接 口 中 的 每 一 个 方 法 都 要 以 事 件 对 象 为 参 数 事 件 源 中 要 保 存 和 它 有 监 听 关 系 的 监 听 器 事 件 源 给 事 件 监 听 器 发 送 事 件 对 象 : 事 件 源 以 事 件 对 象 作 为 参 数, 调 用 监 听 器 接 口 的 相 应 方 法, 通 过 回 调, 调 用 的 是 不 同 监 听 实 现 类 的 方 法 二 在 Java 的 图 形 编 程 中, 所 有 动 作 ( 事 件 ) 都 已 经 提 供 了 相 应 的 事 件 对 象 和 事 件 监 听 接 口, 例 如 : 实 现 窗 口 的 关 闭 按 钮, 点 击 关 闭 按 钮 会 发 出 相 应 的 事 件 对 象, 相 应 的 调 用 监 听 器 中 实 现 好 的 方 法 相 应 的 方 法 清 参 阅 Java2 SE API 帮 助 文 档 缺 省 适 配 模 式, 通 过 一 个 抽 象 类 实 现 接 口, 抽 象 类 中 的 接 口 方 法 实 现, 都 是 一 个 无 意 义 的 空 实 现, 可 以 继 承 这 个 抽 象 类, 只 覆 盖 向 覆 盖 的 方 法 就 可 以 了 在 java.awt.event 包 中, 会 有 一 些 适 配 类, 也 就 是 把 相 应 的 XXXListener, 换 成 XXXAdapter 就 是 适 配 类 适 配 类 是 抽 象 类, 其 中 对 接 口 XXXListener 中 的 方 法 进 行 了 空 实 现, 实 现 这 个 类, 覆 盖 对 自 己 有 用 的 方 法 在 java.awt.event 包 中 的 ActionEvent 类, 在 以 下 操 作 中 会 发 送 这 个 事 件, 1,JButton 组 件, 按 钮 被 点 击 2,JTextField 组 件, 在 单 行 文 本 域 中 按 Enter 键 3,JCheckBox 组 件, 选 中 了 复 选 框 4,JRadioButton 组 件, 选 中 了 单 选 按 钮 5,JMenu 组 件, 选 中 菜 单 项 添 加 事 件 监 听 : 1 实 现 监 听 接 口 2 将 监 听 器 对 象 注 册 在 组 件 ( 事 件 源 ) 中 ActionEvent 事 件 源 --- 组 件 JButton 按 钮 点 击 触 发 ActionEvent JTextField 单 行 文 本 域 输 入 内 容 以 后 回 车 触 发 ActionEvent jtf.gettext(); // 得 到 文 本 域 中 的 内 容 练 习 : 1 写 一 个 图 形 界 面, 采 用 BorderLayout 布 局, 中 间 的 部 分 放 置 一 个 可 以 滚 动 不 可 编 辑 的 JTextArea, 南 面 放 置 一 个 可 以 编 辑 的 JTextField,

47 但 在 TextField 中 输 入 文 字 并 按 下 回 车 的 时 候, 文 字 会 添 加 到 TextArea 中 2 为 BAM 添 加 用 户 界 面 需 要 以 下 几 个 类 : BAMClient 其 中 会 包 含 一 个 Frame, 这 是 用 户 主 界 面 MainPanel: 主 界 面, 用 户 可 以 选 择 开 户 或 者 登 录 RegisterPanel: 用 户 开 户 具 体 用 到 的 界 面 LoginPane l: 用 户 登 录 需 要 的 界 面 BusinessPanel: 界 面 上 会 显 示 账 户 的 功 能 至 少 包 括 存 款 和 取 款, 对 于 可 透 支 的 用 户, 还 允 许 用 户 修 改 透 支 额 度, 对 于 贷 款 用 户, 还 允 许 用 户 贷 款 和 还 贷 款 注 : 本 练 习 的 界 面 布 局 不 做 要 求, 请 阅 读 现 有 代 码, 添 加 事 件 处 理 代 码 提 示 : 在 开 户 或 者 登 录 之 后 都 会 跳 到 BusinessPanel, 而 用 户 点 击 了 交 易 之 后, 界 面 停 留 在 BusinessPanel 要 随 时 注 意 在 BusinessPanel 上 根 据 数 据 的 变 化 更 新 显 示 信 息 三 多 线 程 C++ 的 多 进 程 是 OS 系 统 并 发 的 一 个 任 务 Java 中 没 有 多 进 程, 一 个 JVM 就 是 一 个 进 程 线 程 是 在 进 程 中 并 发 的 一 个 顺 序 的 执 行 流 程 多 进 程 : 划 分 时 间 片, 宏 观 上 并 行, 微 观 上 串 行 多 线 程 :cpu 在 进 程 内 部 再 划 分 时 间 片 CPU, 代 码, 数 据 进 程 : 进 程 间 数 据 独 立 线 程 : 数 据 空 间 共 享, 堆 空 间 的 共 享 ( 堆 空 间 中 存 放 的 是 对 象 ), 栈 空 间 是 独 立 的 所 以 线 程 间 切 换 容 易, 称 为 轻 量 级 进 程 一 个 线 程 对 象 代 表 了 一 个 线 程, 并 非 就 是 一 个 线 程 线 程 是 操 作 系 统 中 负 责 维 护 的 资 源 java.lang.thread 类 的 一 个 对 象 就 代 表 一 个 线 程 线 程 是 底 层 OS 维 护 的 资 源,JVM 跑 在 OS 上, 在 JVM 中 创 建 一 个 Thread 对 象, 调 用 其 start () 方 法, 底 层 OS 会 申 请 一 个 线 程 资 源, 线 程 对 象 可 到 底 层 管 理 一 个 线 程 创 建 好 线 程 之 后, 把 要 让 线 程 执 行 的 代 码 封 装 到 线 程 对 象 中 ( 覆 盖 run() 方 法 ) 实 现 线 程 代 码 的 方 式 : 1 继 承 Thread 类, 覆 盖 run() 方 法 去 底 层 申 请 线 程 并 运 行, 对 线 程 对 象 调 start() 方 法,main 方 法 是 一 个 主 线 程 宏 观 并 行, 微 观 串 行 2 实 现 Runnable 接 口 使 用 多 态 获 得 Runnable 对 象, 成 为 目 标 对 象

48 再 利 用 目 标 对 象 构 造 线 程 对 象 Thread t = new Thread(target); 四 多 线 程 的 状 态 转 换 图 (7 状 态 图 ) 见 另 一 文 件, 名 为 Thread.pdf 作 业 : 用 两 种 方 式 实 现 两 个 线 程, 一 个 线 程 负 责 打 印 , 另 一 个 线 程 打 印 A-Z, 反 复 打 印 100 遍 CoreJava 第 十 三 天 13.1 阻 塞 状 态 初 始 状 态 阻 塞 状 态 终 止 状 态 \ / ^ 1 ^ \ / \ 2sleep / \start / \ 3join /stop \ / \ / V V \ / 可 运 行 状 态 OS 选 中 \ 运 行 状 态 ( 只 缺 CPU) \ CPU 到 期 或 调 用 yield 下 面 为 线 程 中 的 7 中 非 常 重 要 的 状 态 :( 有 的 书 上 也 只 有 认 为 前 五 种 状 态 : 而 将 锁 池 和 等 待 池 都 看 成 是 阻 塞 状 态 的 特 殊 情 况 : 这 种 认 识 也 是 正 确 的, 但 是 将 锁 池 和 等 待 池 单 独 分 离 出 来 有 利 于 对 程 序 的 理 解 ) 1, 初 始 状 态, 线 程 创 建, 线 程 对 象 调 用 start() 方 法 2, 可 运 行 状 态, 也 就 是 等 待 Cpu 资 源, 等 待 运 行 的 状 态 3, 运 行 状 态, 获 得 了 cpu 资 源, 正 在 运 行 状 态 4, 阻 塞 状 态, 也 就 是 让 出 cpu 资 源, 进 入 一 种 等 待 状 态, 而 且 不 是 可 运 行 状 态, 有 三 种 情 况 会 进 入 阻 塞 状 态 1) 如 等 待 数 据 输 入 ( 输 入 设 备 进 行 处 理, 而 CPU 不 处 理 ), 则 放 入 阻 塞, 直 到 输 入 完 毕, 阻 塞 结 束 后 会 进 入 可 运 行 状 态 2) 线 程 休 眠, 线 程 对 象 调 用 sleep() 方 法, 阻 塞 结 束 后 会 进 入 可 运 行 状 态 即 恢 复 执 行 间 片, 继 续 运 行 其 他 程 序 public static void sleep(long millis) throws InterruptedException 括 号 中 以 毫 秒 为 单 位, 使 线 程 停 止 一 段 时 间, 间 隔 期 满 后, 线 程 不 一 定 立 当 main() 运 行 完 毕, 即 使 在 结 束 时 时 间 片 还 没 有 用 完, CPU 也 放 弃 此 时

49 try{ 类 run 方 法 没 有 抛 出 异 常 Thread.sleep(1000); catch(interruptedexception e){ e.printstacktrace(e); 线 程 中 有 异 常, 只 能 trycatch, 子 类 中 不 能 抛 出 比 父 类 更 多 的 异 常, 父 3) 线 程 对 象 2 调 用 线 程 对 象 1 的 join() 方 法, 那 么 线 程 对 象 2 进 入 阻 塞 状 态, 直 到 线 程 对 象 1 中 止 public final void join() throws InterruptedException 表 示 其 他 运 行 线 程 放 弃 执 行 权, 进 入 阻 塞 状 态, 直 到 调 用 线 程 结 束 实 际 上 是 把 并 发 的 线 程 变 为 串 行 运 行 t1 num t2 char if(c=='m') -> t1.join() //t2 对 t1 调 用 join,t2 进 入 了 阻 塞 状 态 // 当 条 件 成 立 时,t1 加 入 打 印 数 字, 一 直 到 打 印 完, 此 时 t2 继 续 运 行 5, 中 止 状 态, 也 就 是 执 行 结 束 6, 锁 池 状 态 7, 等 待 队 列 13.2 共 享 数 据 的 并 发 处 理 数 据 的 错 误 发 生 多 线 程 并 发 访 问 同 一 个 对 象 ( 临 界 资 源 ) 破 坏 了 原 子 操 作, 就 会 发 生 数 据 不 一 致 的 情 况 共 享 数 据 的 并 发 处 理 多 线 程 同 时 并 发 访 问 的 资 源 叫 做 临 界 资 源 多 个 线 程 同 时 访 问 对 象 并 要 求 操 作 相 同 资 源 时 分 割 了 原 子 操 作 就 会 出 现 问 题 ( 原 子 操 作, 不 可 再 分 的 操 作 ) 会 出 现 数 据 的 不 一 致 或 数 据 不 完 整, 为 避 免 这 种 现 象 采 用 对 访 问 的 线 程 做 限 制 的 方 法 互 斥 锁 机 制, 利 用 每 个 对 象 都 有 一 个 monitor( 锁 标 记 ), 当 线 程 拥 有 这 个 锁 标 记 时 才 能 访 问 这 个 资 源, 没 有 锁 标 记 便 进 入 锁 池 任 何 一 个 对 象 系 统 都 会 为 其 创 建 一 个 互 斥 锁, 这 个 琐 是 为 了 分 配 给 线 程 的, 防 止 打 断 原 子 操 作 每 个 对 象 的 锁 只 能 分 配 给 一 个 线 程 Synchronized 用 法 1.Synchronized 修 饰 代 码 块 ( 同 步 代 码 块 ), public void push(char c){ synchronized(this)// 只 有 持 有 当 前 对 象 锁 标 记 的 线 程 才 能 访 问 这 个 代 码 块 {...

50 对 括 号 内 的 对 象 加 锁, 只 有 拿 到 锁 标 记 的 对 象 才 能 执 行 该 代 码 块 2.Synchronized 修 饰 方 法 public synchronized void push(char c) {... 在 整 个 方 法 里, 对 当 前 对 象 的 加 锁, 只 有 拿 到 锁 标 记 的 对 象 才 能 执 行 该 方 法 初 始 状 态 阻 塞 状 态 终 止 状 态 \ / 1 \ / \ 2sleep / \start / \ 3join /stop \ / \ / \ / 可 运 行 状 态 _ OS 选 中 _\ 运 行 状 态 ( 只 缺 CPU) \ CPU 到 期 或 调 用 yield / \ / \ Synchronized/ \ / \ 锁 池 状 态 锁 池 : 一 个 空 间, 每 个 对 象 都 有 一 个, 用 来 存 放 等 待 锁 标 记 的 线 程 当 一 个 对 象 中 有 了 锁 标 记, 不 会 释 放 其 它 对 象 的 锁 标 记 当 t1 线 程 正 在 访 问 对 象 O 的 同 步 方 法 时, 别 的 线 程 t2 不 能 访 问 O 的 任 何 同 步 方 法, 但 还 是 可 以 访 问 其 它 的 非 同 步 方 法 ArrayList Vector list / \ / \ / \ ArrayList Vector( 所 有 方 法 都 做 成 了 同 步 ) 构 造 方 法 抽 象 方 法 静 态 方 法 对 象 没 有 完 全 构 造 好 了, 没 有 当 前 对 象 概 念 抽 象 方 法 没 有 代 码 块, 没 用 是 对 类 对 象 的 加 锁

51 注 意 : 构 造 方 法 不 能 Synchronized 修 饰 静 态 方 法 可 以 用 Synchronized 修 饰 ( 是 对 类 对 象 加 锁, 类 对 象 会 在 反 射 时 讲 到 ) 抽 象 方 法 不 能 用 Synchronized 修 饰, 不 影 响 子 类 覆 盖, 子 类 在 覆 盖 这 个 方 法 是 可 以 加 Synchronized, 也 可 以 不 加 Synchronized, 所 以 根 据 Java 不 允 许 写 废 代 码 的 特 点 是 不 能 写 在 一 起 练 习 : 1 用 数 组 实 现 个 栈 ; 一 个 线 程 负 责 入 栈 一 个 线 程 负 责 出 栈 ; 长 度 为 6 char[6], T1, Push A~Z T2, Pop 长 度 为 6, 并 且 不 允 许 扩 充 注 意 : 对 当 前 对 象 加 锁, 一 个 代 码 块 或 者 方 法 是 同 步 的 (Synchronized), 当 前 对 象 的 锁 标 记 没 有 分 配 出 去 时, 有 一 个 线 程 来 访 问 这 个 代 码 块 时, 就 会 的 到 这 个 对 象 的 锁 标 记, 直 到 这 个 线 程 结 束 才 会 释 放 着 个 锁 标 记, 其 他 想 访 问 这 个 代 码 块 或 者 是 方 法 线 程 就 会 进 入 这 个 对 象 锁 池, 如 果 没 有 得 到 当 前 对 象 的 锁 标 记, 就 不 能 访 问 这 个 代 码 块 或 者 是 方 法 当 一 个 线 程 想 要 获 得 某 个 对 象 锁 标 记 而 进 入 锁 池, 这 个 线 程 又 持 有 其 他 对 象 的 锁 标 记, 那 么 这 个 线 程 也 不 会 释 放 持 有 的 锁 标 记 注 : 方 法 的 Synchronized 特 性 本 身 不 会 被 继 承, 只 能 覆 盖 线 程 因 为 未 拿 到 锁 标 记 而 发 生 阻 塞 进 入 锁 池 (lock pool) 每 个 对 象 都 有 自 己 的 一 个 锁 池 的 空 间, 用 于 放 置 等 待 运 行 的 线 程 由 系 统 决 定 哪 个 线 程 拿 到 锁 标 记 并 运 行 使 用 互 斥 锁 的 注 意 事 项 举 例 : 男 孩 和 女 孩 例 子, 每 个 女 孩 是 一 个 对 象, 每 个 男 孩 是 个 线 程 每 个 女 孩 都 有 自 己 的 锁 池 每 个 男 孩 可 能 在 锁 池 里 等 待 Class Girl{ Public void hand(){ Public syncronized void kiss(){ Class Boy extends Thread{ Public void run(){ 注 意 : 只 读 不 用 加 同 步, 只 写 也 不 用 加 同 步, 只 有 读 写 操 作 兼 而 有 之 时 才 加 同 步

52 注 意 : 在 java.io 包 中 Vector 和 HashTable 之 所 以 是 线 程 安 全 的, 是 因 为 每 个 方 法 都 有 synchronized 修 饰 Static 方 法 可 以 加 synchronized, 锁 的 是 类 对 象 但 是 Vector 是 jdk 1.0 的 ArrayList 是 jdk1.2 所 以 实 际 应 用 还 是 使 用 ArrayList 注 意 : 内 同 步, 外 同 步, 内 同 步, 即, 类 内 的 方 法 加 同 步 (synchronized) 修 饰, 外 同 步 即, 在 需 要 控 制 只 能 由 一 个 线 程 进 行 访 问 时, 把 需 要 控 制 的 方 法 写 在 同 步 代 码 块 里 CoreJava 第 十 四 天 14.1 多 线 程 的 通 信 因 为 线 程 的 死 锁, 从 而 引 发 要 多 线 程 的 通 信 死 锁 : 每 个 线 程 不 释 放 自 己 拥 有 的 资 源, 却 申 请 别 的 线 程 拥 有 的 资 源, 会 造 成 死 锁 问 题 线 程 间 的 通 信 : 等 待 通 知 机 制 每 一 个 对 象 都 有 一 个 等 待 队 列 线 程 t1 对 O 调 用 wait 方 法, 必 须 是 在 对 O 加 锁 的 同 步 代 码 块 中 结 果 :1 线 程 t1 会 释 放 它 拥 有 的 所 有 的 锁 标 记 2 会 进 入 O 的 等 待 队 列, 开 始 阻 塞 线 程 t2 对 o 调 用 notify/notifyall 方 法 时, 也 必 须 是 在 对 o 加 锁 的 同 步 代 码 块 中 结 果 : 会 从 o 的 等 待 队 列 中 释 放 一 个 / 全 部 线 程 初 始 状 态 阻 塞 状 态 终 止 状 态 \ / 1 \ / \ 2sleep / \start / \ 3join /stop \ / \ / \ / 可 运 行 状 态 _ OS 选 中 _ 运 行 状 态 ( 只 缺 CPU) \ CPU 到 期 或 调 用 yield / \ \ / \wait \ Synchronized/ \ \ / \ \ / \ \ / \ \ 锁 池 状 态 < 等 待 队 列 notify/notifyall

53 练 习 1 利 用 线 程 的 通 信 机 制, 用 两 个 线 程 打 印 以 下 的 结 果 : 1 2 A 3 4 B 5 6 C 7 8 D Y Z 2 思 考 为 什 么 调 用 wait() 方 法 之 前 用 while 判 断, 而 不 用 if 判 断 currentthread public static Thread currentthread() 返 回 对 当 前 正 在 执 行 的 线 程 对 象 的 引 用 14.2 IO 流 java.io Class File 一 个 File 对 象 代 表 了 一 个 文 件 或 目 录 File f=new File("1.txt");// 在 堆 里 申 请 了 个 File 对 象 的 空 间 f.createnewfile();// 创 建 了 个 文 件 对 象, 不 会 产 生 文 件, 只 有 操 作 File 对 去 创 建 文 件 f.delete(); f.mkdir(); System.out.println(f.getName());// 相 对 路 径 System.out.println(f.getAbsolutePath());// 绝 对 路 径 File[] listfiles(filefilter filter) 名 满 足 特 定 过 滤 器 返 回 表 示 此 抽 象 路 径 名 所 表 示 目 录 中 的 文 件 和 目 录 的 抽 象 路 径 名 数 组, 这 些 路 径 java.io 接 口 FileFilter accept boolean accept(file pathname) File pathname 是 指 被 遍 历 目 录 中 所 有 文 件 和 目 录 作 业 : 打 印 目 录 下 所 有 的.java 文 件, 包 括 子 目 录 ( 提 示 : 递 归 ) io 流 是 用 于 JVM 和 数 据 源 之 间 交 换 数 据 DB JVM 流 net file 一 个 流 也 是 个 对 象

54 流 的 分 类 : 输 入 流 输 出 流 装 饰 模 式 字 节 流 字 符 流 节 点 流 过 滤 流 ( 功 能, 过 滤 流 是 给 其 它 增 加 个 功 能, 本 身 不 传 输 数 据 ) 枪 ( 节 点 流 ) 武 器 / \ / \ 零 件 / \ \ / \ \ \ \ 瞄 消 M P S L ( 过 滤 流 ) 字 节 输 入 流 java.io 类 InputStream 字 节 输 入 流 的 所 有 类 的 超 类 java.io 类 FileInputStream public FileInputStream(String name) throws FileNotFoundException// 文 件 不 存 在 会 抛 异 常 FileInputStream(File file) FileInputStream(FileDescriptor fdobj) FileInputStream 中 方 法 介 绍 void close() 关 闭 此 文 件 输 入 流 并 释 放 与 此 流 有 关 的 所 有 系 统 资 源 int read() 从 此 输 入 流 中 读 取 一 个 数 据 字 节 返 回 下 一 个 数 据 字 节 ; 如 果 已 到 达 文 件 末 尾, 则 返 回 -1 int read(byte[] b) 从 此 输 入 流 中 将 最 多 b.length 个 字 节 的 数 据 读 入 一 个 字 节 数 组 中 返 回 -1 返 回 : 读 入 缓 冲 区 的 字 节 总 数, 如 果 因 为 已 经 到 达 文 件 末 尾 而 没 有 更 多 的 数 据, 则 int read(byte[] b, int off, int len) 从 此 输 入 流 中 将 最 多 len 个 字 节 的 数 据 读 入 一 个 字 节 数 组 中 CoreJava 第 十 五 天 DataInputStream/DataOutStream 增 加 读 写 关 流 只 关 最 外 层 的 过 滤 流 就 行 了 \ BufferedInputStream/BufferedOutputStream 增 加 缓 冲 区

55 void flush() 刷 新 此 缓 冲 的 输 出 流 管 道 流 ( 和 UnixC++ 中 的 FIFO 相 同 ) PipedInputStream 和 PipedOutputStream ( 字 节 流 ) 这 两 个 是 节 点 流, 注 意, 用 来 在 线 程 间 通 信 所 有 输 入 流 读 方 法 都 是 阻 塞 的 PipedOutputStream pos=new PipedOutputStream(); PipedInputStream pis=new PipedInputStream(); try { pos.connect(pis); new Producer(pos).start();// 线 程 类 对 象, 在 构 造 时, 使 用 管 道 流 通 信 new Consumer(pis).start();// 线 程 类 对 象, 在 构 造 时, 使 用 管 道 流 通 信 catch(exception e) { e.printstacktrace(); 随 机 存 取 文 件 RondomAccessFile 类 允 许 随 机 访 问 文 件, 这 个 类 也 是 支 持 直 接 输 出 输 入 各 种 数 据 类 型 GetFilepoint() 可 以 知 道 文 件 中 的 指 针 位 置, 使 用 seek() 定 位 Mode( r : 随 机 读 ; w : 随 机 写 ; rw : 随 机 读 写 ) 1) 实 现 了 二 个 接 口 :DataInput 和 DataOutput; 2) 只 要 文 件 能 打 开 就 能 读 写 ; 3) 通 过 文 件 指 针 能 读 写 文 件 指 定 位 置 ; 4) 可 以 访 问 在 DataInputStream 和 DataOutputStream 中 所 有 的 read() 和 write() 操 作 ; 5) 在 文 件 中 移 动 方 法 : a. long getfilepointer(): 返 回 文 件 指 针 的 当 前 位 置 b. void seek(long pos): 设 置 文 件 指 针 到 给 定 的 绝 对 位 置 c. long length(): 返 回 文 件 的 长 度 15.2 字 符 流 字 符 流 可 以 解 决 编 程 中 字 符 的 编 码 问 题 从 字 符 到 整 数, 对 字 符 集 和 整 数 集 建 立 一 一 对 应 的 关 系, 就 算 叫 做 编 码, 从 整 数 映 射 到 字 符, 就 叫 做 解 码 编 码 问 题 : 字 节 流 的 字 符 编 码 : 字 符 编 码 把 字 符 转 换 成 数 字 存 储 到 计 算 机 中, 按 ASCii 将 字 母 映 射 为 整 数

56 把 数 字 从 计 算 机 转 换 成 相 应 的 字 符 的 过 程 称 为 解 码 编 码 的 方 式 : 每 个 字 符 对 应 一 个 整 数 不 同 的 国 家 有 不 同 的 编 码, 当 编 码 方 式 和 解 码 方 式 不 统 一 时, 产 生 乱 码 因 为 美 国 最 早 发 展 软 件, 所 以 每 种 的 编 码 都 向 上 兼 容 ASCII 所 以 英 文 没 有 乱 码 ASCII( 数 字 英 文 )1 个 字 符 占 一 个 字 节 ( 所 有 的 编 码 集 都 兼 容 ASCII) ISO8859-1( 欧 洲 ) 1 个 字 符 占 一 个 字 节 GB-2312/GBK 1 个 字 符 占 两 个 字 节 Unicode 1 个 字 符 占 两 个 字 节 ( 网 络 传 输 速 度 慢 ) UTF-8 变 长 字 节, 对 于 英 文 一 个 字 节, 对 于 汉 字 两 个 或 三 个 字 节 InputStreamReader 和 OutputStreamWriter( 字 节 流 转 化 成 字 符 流 的 桥 转 换 器 ) 这 两 个 类 不 是 用 于 直 接 输 入 输 出 的, 他 是 将 字 节 流 转 换 成 字 符 流 的 桥 转 换 器, 并 可 以 指 定 编 解 码 方 式 Reader 和 Writer ( 字 符 流 类, 所 有 字 符 流 的 父 类 型 ) 1) Java 技 术 使 用 Unicode 来 表 示 字 符 串 和 字 符, 而 且 提 供 16 位 版 本 的 流, 以 便 用 类 似 的 方 法 处 理 字 符 2) InputStreamReader 和 OutputStreamWriter 作 为 字 节 流 与 字 符 流 中 的 接 口 3) 如 果 构 造 了 一 个 连 接 到 流 的 Reader 和 Writer, 转 换 规 则 会 在 使 用 缺 省 平 台 所 定 义 的 字 节 编 码 和 Unicode 之 间 切 换 BufferedReader/(BufferedWriter, 不 常 用 )( 这 两 个 类 需 要 桥 转 换 ) PrintWriter( 带 缓 存 的 字 符 输 出 流, 不 需 要 桥 转 换 ) 常 用 输 入 输 出 类 型, 不 需 要 桥 接, 其 中 其 它 方 法 请 参 看 API 文 档 以 上 两 个 都 是 过 滤 流, 需 要 用 其 他 的 节 点 流 来 作 参 数 构 造 对 象 BufferedReader 的 方 法 : readline():string, 当 他 的 返 回 值 是 null 时, 就 表 示 读 取 完 毕 了 要 注 意, 再 写 入 时 要 注 意 写 换 行 符, 否 则 会 出 现 阻 塞 BufferedWriter 的 方 法 :newline(), 这 个 方 法 会 写 出 一 个 换 行 符 PrintWriter 的 方 法 :println(.string,object 等 等 ) 和 write(),println(...) 这 个 方 法 就 不 必 再 写 换 行 符 了, 在 使 用 时 会 自 动 换 行 注 意 : 在 使 用 带 有 缓 冲 区 的 流 时, 在 输 入 之 后 就 要 flush() 方 法, 把 缓 冲 区 数 据 发 出 去 原 则 : 保 证 编 解 码 方 式 的 统 一, 才 能 不 至 于 出 现 错 误 java.io 包 的 InputStreamread 输 入 流 的 从 字 节 流 到 字 符 流 的 桥 转 换 类 这 个 类 可 以 设 定 字 符 转 换 方 式 OutputStreamred: 输 出 流 的 字 节 流 桥 转 换 成 字 符 流 Bufferread 有 readline() 使 得 字 符 输 入 更 加 方 便

57 在 I/O 流 中, 所 有 输 入 方 法 都 是 阻 塞 方 法 Bufferwrite 给 输 出 字 符 加 缓 冲, 因 为 它 的 方 法 很 少, 所 以 使 用 父 类 PrintWrite, 它 可 以 使 用 字 节 流 对 象, 而 且 方 法 很 多 15.3 StringTokenizer java.util 类 StringTokenizer 15.4 对 象 序 列 化 把 对 象 放 在 IO 流 上 ObjectInputStream 和 ObjectOutputStream( 对 象 流 ) 对 象 流 是 过 滤 流, 需 要 节 点 流 作 参 数 来 构 造 对 象 用 于 直 接 把 对 象 写 入 文 件 和 从 文 件 读 取 对 象 只 有 实 现 了 Serializable 接 口 的 类 型 的 对 象 才 可 以 被 读 写, Serializable 接 口 是 个 标 记 接 口, 其 中 没 有 定 义 方 法 对 象 会 序 列 化 成 一 个 二 进 制 代 码 writeobject(o),readobject() 这 两 个 是 对 象 读 写 操 作 时 用 的 方 法 Object o = new Object(); FileOutputStream fos=new FileOutputStream("Object.txt"); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeobject(o); oos.close(); FileInputStream fis =new FileInputStream( Object.txt ); ObjectInputStream ois =new ObjectInputStream(fis); Object o = (Object)Ois.readObject(); ois.close(); 对 象 流 读 取 结 束 返 回 EOFException 异 常 对 象 一 个 类 中 有 其 他 类 型 的 对 象, 那 么, 这 个 类 实 现 了 Serializable 接 口, 在 对 象 序 列 化 时, 也 同 样 要 求 这 个 类 中 属 性 都 能 够 对 象 序 列 化 ( 基 本 类 型 除 外 ) 注 意 : 对 于 对 象 流 的 操 作, 在 写 对 象 时 要 一 次 写 入 完 毕, 如 果 使 用 追 加 模 式 写 入, 只 会 读 取 到 上 一 次 写 入 的 对 象, 使 用 对 象 流 写 入 时, 会 先 写 入 一 个 头 部, 然 后 写 入 数 据, 最 后 加 上 结 束 符 号, 如 果 使 用 追 加 方 式 写 入 的 话, 那 就 会 在 结 束 符 号 继 续 向 下 写 入, 但 是 在 读 取 时 只 会 读 到 结 束 符 为 止, 以 后 再 次 写 入 的 数 据 就 会 丢 失 注 意 : 在 使 用 对 象 流 写 入 对 象 时 要 一 次 向 文 件 写 入, 不 能 够 采 用 追 加 方 式 serialver 命 令 判 断 是 否 一 个 属 性 或 对 象 可 序 列 化,

58 serialver TestObject(TestObject 必 须 为 已 经 编 译, 也 就 是.class) 执 行 结 果 : 如 果 不 可 序 列 化 ; 则 出 现 不 可 序 列 化 的 提 示 如 果 可 以 序 列 化, 那 么 就 会 出 现 序 列 化 的 ID:UID Externalizable 这 是 Serializable 的 子 接 口, 他 可 以 让 用 户 自 定 义 如 何 序 列 化 对 象 readexternal(objectinput in),writeexternal(objectoutput out) 这 是 这 个 接 口 中 的 两 个 方 法, 通 过 这 两 个 方 法 可 以 定 制 序 列 化 过 程 这 个 方 法 不 安 全, 可 以 调 用 以 上 两 个 方 法 改 变 对 象 的 状 态 transient 只 能 用 来 修 饰 属 性 表 示 这 个 属 性 在 对 象 序 列 化 时 将 被 忽 略 transient int num; 表 示 当 我 们 对 属 性 序 列 化 时 忽 略 这 个 属 性 ( 即 忽 略 不 使 之 持 久 化 ) 所 有 属 性 必 须 都 是 可 序 列 化 的, 特 别 是 当 有 些 属 性 本 身 也 是 对 象 的 时 候, 要 尤 其 注 意 这 一 点 java.util.stringtokenizer 类, 这 个 类 是 用 于 字 符 串 截 取 的 StringTokenizer( 参 数 1, 参 数 2) 按 某 种 符 号 隔 开 文 件 StringTokenizer(s, : ) 用 : 隔 开 字 符,s 为 对 象 补 充 : 字 节 流 结 束 返 回 -1, 字 符 流 结 束 返 回 null, 对 象 流 结 束 返 回 EOFException 引 申 异 常 经 常 被 用 在 流 程 控 制, 异 常 也 是 方 法 的 一 种 返 回 形 式 作 业 : 用 字 符 流 把 文 件 中 的 唐 诗 排 列 成 古 文 的 格 式 用 对 象 序 列 化 把 若 干 Employee 对 象 写 到 文 件 中, 再 读 取 出 来 项 目 练 习 : 修 改 Bank 类, 账 户 信 息 会 采 用 对 象 序 列 化 的 方 式 存 放 在 文 件 中. 当 Bank 对 象 生 成 的 时 候 会 读 取 文 件, 设 置 账 户 集 合. 当 账 户 信 息 改 变 的 时 候, 会 随 时 更 新 文 件 设 计 一 个 FileDAO 类 ( 文 件 数 据 访 问 对 象 ), 负 责 对 文 件 的 访 问, 包 括 存 放 账 户, 提 取 账 户 等 方 法, 在 Bank 类 中, 会 通 过 FileDAO 对 象 来 访 问 文 件 注 意 : 如 果 已 有 的 账 户 对 象 会 存 在 文 件 中, 那 么 为 新 的 账 户 对 象 分 配 id 的 做 法 也 应 相 应 的 改 变, 过 去 的 用 static 属 性 的 做 法 不 再 合 适, 应 该 改 为, 把 下 一 个 可 用 的 id 存 放 在 一 个 文 件 中, 每 创 建 一 个 新 对 象 的 时 候 都 会 读 取 这 个 文 件, 获 得 新 对 象 的 id, 并 且 修 改 文 件 中 的 id, 使 其 加 1. 这 个 工 作 可 以 放 在 Account 类 的 构 造 方 法 中 CoreJava 第 十 六 天 网 络 基 础 知 识

59 网 络 编 程 的 目 的 就 是 指 直 接 或 间 接 地 通 过 网 络 协 议 与 其 他 计 算 机 进 行 通 讯 计 算 机 网 络 形 式 多 样, 内 容 繁 杂 网 络 上 的 计 算 机 要 互 相 通 信, 必 须 遵 循 一 定 的 协 议 目 前 使 用 最 广 泛 的 网 络 协 议 是 Internet 上 所 使 用 的 TCP/IP 协 议 IP 地 址 : 计 算 机 在 网 络 中 唯 一 标 识, 相 对 于 internet,ip 为 逻 辑 地 址 IP 地 址 分 类 : A 类 地 址 A 类 地 址 第 1 字 节 为 网 络 地 址, 其 它 3 个 字 节 为 主 机 地 址 另 外 第 1 个 字 节 的 最 高 位 固 定 为 0 A 类 地 址 范 围 : 到 A 类 地 址 中 的 私 有 地 址 和 保 留 地 址 : 到 是 私 有 地 址 ( 所 谓 的 私 有 地 址 就 是 在 互 联 网 上 不 使 用, 而 被 用 在 局 域 网 络 中 的 地 址 ) 到 是 保 留 地 址, 用 做 循 环 测 试 用 的 B 类 地 址 B 类 地 址 第 1 字 节 和 第 2 字 节 为 网 络 地 址, 其 它 2 个 字 节 为 主 机 地 址 另 外 第 1 个 字 节 的 前 两 位 固 定 为 10 B 类 地 址 范 围 : 到 B 类 地 址 的 私 有 地 址 和 保 留 地 址 到 是 私 有 地 址 到 是 保 留 地 址 如 果 你 的 IP 地 址 是 自 动 获 取 IP 地 址, 而 你 在 网 络 上 又 没 有 找 到 可 用 的 DHCP 服 务 器, 这 时 你 将 会 从 到 中 临 得 获 得 一 个 IP 地 址 C 类 地 址 C 类 地 址 第 1 字 节 第 2 字 节 和 第 3 个 字 节 为 网 络 地 址, 第 4 个 个 字 节 为 主 机 地 址 另 外 第 1 个 字 节 的 前 三 位 固 定 为 110 C 类 地 址 范 围 : 到 C 类 地 址 中 的 私 有 地 址 : 到 是 私 有 地 址 D 类 地 址 D 类 地 址 不 分 网 络 地 址 和 主 机 地 址, 它 的 第 1 个 字 节 的 前 四 位 固 定 为 1110 D 类 地 址 范 围 : 到 Mac 地 址 : 每 个 网 卡 专 用 地 址, 也 是 唯 一 的 端 口 (port): 应 用 程 序 ( 进 程 ) 的 标 识 ( 网 络 通 信 程 序 )OS 中 可 以 有 65536(2^16) 个 端 口, 进 程 通 过 端 口 交 换 数 据 连 线 的 时 候 需 要 输 入 IP 也 需 要 输 入 端 口 信 息 计 算 机 通 信 实 际 上 的 主 机 之 间 的 进 程 通 信, 进 程 的 通 信 就 需 要 在 端 口 进 行 联 系 :21 协 议 : 为 了 进 行 网 络 中 的 数 据 交 换 ( 通 信 ) 而 建 立 的 规 则 标 准 或 约 定, 协 议 是 为 了 保 证 通

60 信 的 安 全 不 同 层 的 协 议 是 完 全 不 同 的 OSI 网 络 参 考 模 型 ( 理 论 性 较 强 的 模 型 ) 七 层, 应 用 层 表 示 层 会 话 层 传 输 层 网 络 层 数 据 链 路 层 物 理 层 : 网 络 层 : 寻 址 路 由 ( 指 如 何 到 达 地 址 的 过 程 ) 传 输 层 : 端 口 连 接 TCP 模 型 : 应 用 层 / 传 输 层 / 网 络 层 / 网 络 接 口 层 与 层 之 间 是 单 向 依 赖 关 系, 上 层 依 赖 于 下 层, 下 层 不 依 赖 于 上 层, 层 与 层 之 间 的 连 接 是 虚 连 接 对 等 层 之 间 建 立 协 议 端 口 是 一 种 抽 象 的 软 件 结 构, 与 协 议 相 关 :TCP23 端 口 和 UDT23 端 口 为 两 个 不 同 的 概 念 端 口 应 该 用 1024 以 上 的 端 口, 以 下 的 端 口 都 已 经 设 定 功 能 TCP/IP 模 型 Application (FTP,HTTP,TELNET,POP3,SMPT) Transport (TCP,UDP) Network (IP,ICMP,ARP,RARP) Link (Device driver,.) 注 : IP: 寻 址 和 路 由 ARP(Address Resolution Protocol) 地 址 解 析 协 议 : 将 IP 地 址 转 换 成 Mac 地 址 RARP(Reflect Address Resolution Protocol) 反 相 地 址 解 析 协 议 : 与 上 相 反 ICMP(Internet Control Message Protocol) 检 测 链 路 连 接 状 况 利 用 此 协 议 的 工 具 : ping, traceroute TCP Socket TCP 是 Tranfer Control Protocol 的 简 称, 是 一 种 面 向 连 接 的 保 证 可 靠 传 输 的 协 议 通 过 TCP 协 议 传 输, 得 到 的 是 一 个 顺 序 的 无 差 错 的 数 据 流 发 送 方 和 接 收 方 的 成 对 的 两 个 socket 之 间 必 须 建 立 连 接, 以 便 在 TCP 协 议 的 基 础 上 进 行 通 信, 当 一 个 socket( 通 常 都 是 server socket) 等 待 建 立 连 接 时, 另 一 个 socket 可 以 要 求 进 行 连 接, 一 旦 这 两 个 socket 连 接 起 来, 它 们 就 可 以 进 行 双 向 数 据 传 输, 双 方 都 可 以 进 行 发 送 或 接 收 操 作 1) 服 务 器 分 配 一 个 端 口 号, 服 务 器 使 用 accept() 方 法 等 待 客 户 端 的 信 号, 信 号 一 到 打 开 socket 连 接, 从 socket 中 取 得 OutputStream 和 InputStream 2) 客 户 端 提 供 主 机 地 址 和 端 口 号 使 用 socket 端 口 建 立 连 接, 得 到 OutputStream 和 InputStream

61 TCP/IP 的 传 输 层 协 议 建 立 TCP 服 务 器 端 一 般, 我 们 把 服 务 器 端 写 成 是 分 发 Socket 的, 也 就 是 总 是 在 运 行, 创 建 一 个 TCP 服 务 器 端 程 序 的 步 骤 : 1). 创 建 一 个 ServerSocket 2). 从 ServerSocket 接 受 客 户 连 接 请 求 3). 创 建 一 个 服 务 线 程 处 理 新 的 连 接 4). 在 服 务 线 程 中, 从 socket 中 获 得 I/O 流 5). 对 I/O 流 进 行 读 写 操 作, 完 成 与 客 户 的 交 互 6). 关 闭 I/O 流 7). 关 闭 Socket ServerSocket server = new ServerSocket(post) Socket connection = server.accept(); ObjectInputStream put=new ObjectInputStream(connection.getInputStream()); ObjectOutputStreamo put=newobjectoutputstream(connection.getoutputstream()); 处 理 输 入 和 输 出 流 ; 关 闭 流 和 socket 典 型 的 服 务 器 端 public class Server1 { public static void main(string[] args) throws Exception { ServerSocket ss=new ServerSocket(9000); while(true){ Socket s=ss.accept();// 获 得 一 个 Socket 对 象 Thread t=new Thread1(s);// 分 发 Socket t.start(); class Thread1 extends Thread{ Socket s; public Thread1(Socket s){ this.s=s; public void run(){ try { OutputStream o=s.getoutputstream(); PrintWriter out=new PrintWriter(o); out.println("he llo Client"); out.flush();

62 s.close(); catch (IOException e) { // TODO Auto-generated catch block e.printstacktrace(); 建 立 TCP 客 户 端 创 建 一 个 TCP 客 户 端 程 序 的 步 骤 : 1). 创 建 Socket 2). 获 得 I/O 流 3). 对 I/O 流 进 行 读 写 操 作 4). 关 闭 I/O 流 5). 关 闭 Socket Socket connection = new Socket( , 7777); ObjectInputStream input=new ObjectInputStream(connection.getInputStream()); ObjectOutputStream utput=new ObjectOutputStream(connection.getOutputStream()); 处 理 输 入 和 输 出 流 ; 关 闭 流 和 socket 练 习 : 实 现 一 个 网 络 应 用, 客 户 端 会 给 服 务 器 发 送 一 个 字 符 串, 服 务 器 会 把 这 个 字 符 串 转 换 成 大 写 形 式 发 回 给 客 户 端 并 有 客 户 端 显 示, 同 时, 服 务 器 会 告 知 客 户 端, 他 是 第 几 个 客 户 端 UDP socket 这 种 信 息 传 输 方 式 相 当 于 传 真, 信 息 打 包, 在 接 受 端 准 备 纸 先 由 客 户 端 给 服 务 器 发 消 息 以 告 诉 服 务 器 客 户 端 的 地 址 特 点 : 1) 基 于 UDP 无 连 接 协 议 2) 不 保 证 消 息 的 可 靠 传 输 3) 它 们 由 Java 技 术 中 的 DatagramSocket 和 DatagramPacket 类 支 持 DatagramSocket( 邮 递 员 ): 对 应 数 据 报 的 Socket 概 念, 不 需 要 创 建 两 个 socket, 不 可 使 用 输 入 输 出 流 DatagramPacket( 信 件 ): 数 据 包, 是 UDP 下 进 行 传 输 数 据 的 单 位, 数 据 存 放 在 字 节 数 组 中, 其 中 包 括 了 目 标 地 址 和 端 口 以 及 传 送 的 信 息 ( 所 以 不 用 建 立 点 对 点 的 连 接 ) DatagramPacket 的 分 类 : 用 于 接 收 :DatagramPacket(byte[] buf,int length) DatagramPacket(byte[] buf,int offset,int length) 用 于 发 送 :DatagramPacket(byte[] buf,int length, InetAddress address,int port )

63 DatagramPacket(byte[] buf,int offset,int length,inetaddress address,int port) 注 :InetAddress 类 网 址 用 于 封 装 IP 地 址 没 有 构 造 方 法, 通 过 InetAddress.getBy Address(byte[] addr):inetaddress InetAddress.getByName(String host):inetaddress 等 建 立 UDP 发 送 端 创 建 一 个 UDP 的 客 户 端 的 程 序 的 步 骤 : 号 1). 创 建 一 个 DatagramPacket, 其 中 包 含 发 送 的 数 据 和 接 收 方 的 IP 地 址 和 端 口 2). 创 建 一 个 DatagramSocket, 其 中 包 含 了 发 送 方 的 IP 地 址 和 端 口 号 3). 发 送 数 据 4). 关 闭 DatagramSocket byte[] buf = new byte[1024]; DatagramSocket datagramsocket = new DatagramSocket(13);// set port DatagramPackage intputpackage = new DatagramPackage(buf,buf.length); datagramsocket.receive(inputpackage); DatagramPackage outputpackage = new DatagramPackage(buf,0,buf.length,inetAddress,port); datagramsocket.send(outputpackage); // 客 户 端 向 服 务 器 发 信 的 过 程 没 建 立 流 所 以 不 用 断 开 建 立 UDP 接 受 端 创 建 一 个 UDP 的 服 务 器 端 的 程 序 的 步 骤 : 1). 创 建 一 个 DatagramPacket, 用 于 存 储 发 送 方 发 送 的 数 据 及 发 送 方 的 IP 地 址 和 端 口 号 2). 创 建 一 个 DatagramSocket, 其 中 指 定 了 接 收 方 的 IP 地 址 和 端 口 号 3). 接 收 数 据 4). 关 闭 DatagramSocket byte[] buf = new byte[1024]; DatagramSocket datagramsocket = new DatagramSocket();// 不 用 设 端 口, 因 为 发 送 的 包 中 端 口 DatagramPackage DatagramPackage(Buf,buf.length,serverAddress,serverPort); DatagramPackage inputpackage=new DatagramPackage(buf,0,buf.length); 一 封 空 信 datagramsocket.receive(inputpackage); outputpackage=new // 收 信 之 前 要 准 备 UDP 处 理 多 客 户 端, 不 必 多 线 程, 回 信 可 以 一 封 一 封 的 回 在 收 发 信 设 置 为 死 循 环 java.net.url 统 一 资 源 定 位 器

64 定 位 在 internet 上 的 某 一 资 源 更 高 层 的 网 络 传 输 常 用 格 式 协 议 名 :// 主 机 名 : 端 口 号 / 定 位 寻 找 主 机 内 部 的 某 一 资 源 作 用 : 1 必 须 完 成 网 络 聊 天 室, 以 广 播 的 形 式 传 输 数 据 2 QQ 聊 天 室 实 现 点 对 点 的 数 据 传 输 3 统 计 一 个 目 录 下 的 所 有.java 文 件 及 子 目 录 下 的 ".java" 文 件 总 共 多 少 行 CoreJava 第 十 七 天 一 Java5.0 新 特 性 1 编 译 器 的 功 能 更 加 强 大,JVM 变 化 不 大 2 Java 在 逐 渐 与 C++ 融 合 3 五 小 点, 四 大 点 二 五 小 点 1 自 动 封 箱 AutoBoxing/ 自 动 解 封 自 动 封 箱 和 自 动 拆 箱, 它 实 现 了 简 单 类 型 和 封 装 类 型 的 相 互 转 化 时, 实 现 了 自 动 转 化 byte b -128~127 Byte b 在 以 上 数 量 的 基 础 上 多 一 个 null 简 单 类 型 和 封 装 类 型 之 间 的 差 别 封 装 类 可 以 等 于 null, 避 免 数 字 得 0 时 的 二 义 性 Integer i=null; int ii=i; // 会 抛 出 NullException 异 常 相 当 于 int ii=i.intvalue(); Integer i=1; // 相 当 于 Integer i=new Integer(1); i++; // i = new Integer(i.intValue()+1); 在 基 本 数 据 类 型 和 封 装 类 之 间 的 自 动 转 换 5.0 之 前 Integer i=new Integer(4); int ii= i.intvalue(); 5.0 之 后 Integer i=4; Long l=4.3;

65 public void m(int i){... public void m(integer i){... 以 上 两 个 函 数 也 叫 方 法 重 载 自 动 封 箱 解 箱 只 在 必 要 的 时 候 才 进 行 能 不 封 箱 找 到 匹 配 的 就 不 封 箱 2 静 态 引 入 StaticImport 使 用 类 中 静 态 方 法 时 不 用 写 类 名 System.out.println(Math.round(PI)); 可 以 用 以 下 代 码 实 现 : import static java.lang.system.*; // 注 意, 要 写 " 类 名.* " import static java.lang.math.*; out.println(round(pi)); 注 意 : 静 态 引 入 的 方 法 不 能 重 名 3 for-each 统 一 了 遍 历 数 组 和 遍 历 集 合 的 方 式 for(object o:list){ //Object o 表 示 每 个 元 素 的 类 型,list 表 示 要 遍 历 的 数 组 或 集 合 的 名 字 System.out.println(o); // 打 印 集 合 或 数 组 中 的 每 个 元 素 4 可 变 长 参 数 处 理 方 法 重 载 中, 参 数 类 型 相 同, 个 数 不 同 的 情 况 public void m(int... is){... int... is 相 当 于 一 个 int[] is 编 译 器 会 把 给 定 的 参 数 封 装 到 一 个 数 组 中, 再 传 给 方 法 在 一 个 方 法 中 只 能 有 一 个 可 变 长 参 数, 而 且, 必 须 放 在 最 后 一 个 参 数 的 位 置 5 格 式 化 输 入 / 输 出 java.util.formatter 类 对 格 式 的 描 述 System.out.printf("He llo %s",str); // 打 印 字 符 串 类 型 的 变 量, 用 一 个 占 位 符 格 式 化 I/O(Formatted I/O) java.util.sacner 类 可 以 进 行 格 式 化 的 输 入, 可 以 使 用 控 制 台 输 入, 结 合 了 BufferedReader 和 StringTokener 的 功 能 三 四 大 点 1 枚 举 枚 举 是 一 个 类, 并 且 这 个 类 的 对 象 是 现 成 的, 在 定 义 类 的 时 候, 即 定 义 好 了 对 象 程 序 员 要 使 用 的 时 候, 只 能 从 中 选 择, 无 权 创 建

66 enum 枚 举 名 { 枚 举 值 1(..), 枚 举 值 2(..),...; (1) 在 5.0 之 前 使 用 模 式 做 出 一 个 面 向 对 象 的 枚 举 final class Season{ public static final Season SPRING=new Season(); public static final Season WINTER=new Season(); public static final Season SUMMER=new Season(); public static final Season AUTUMN=new Season(); private Season(){ 完 全 等 价 于 enum Season2{ SPRING(..),// 枚 举 值 SUMMER(..), AUTUMN(..), WINTER(..) 枚 举 本 质 上 也 是 一 个 类,Enum 是 枚 举 的 父 类 这 个 类 编 译 以 后 生 成 一 个.class 类 这 个 类 有 构 造 方 法, 但 是 是 私 有 的 枚 举 中 的 values() 方 法 会 返 回 枚 举 中 的 所 有 枚 举 值 枚 举 中 可 以 定 义 方 法 和 属 性, 最 后 的 一 个 枚 举 值 要 以 分 号 和 类 定 义 分 开, 枚 举 中 可 以 定 义 的 构 造 方 法 枚 举 不 能 继 承 类 ( 本 身 有 父 类 ), 但 可 以 实 现 接 口, 枚 举 不 能 有 子 类 也 就 是 final 的, 枚 举 的 构 造 方 法 是 private( 私 有 的 ) 枚 举 中 可 以 定 义 抽 象 方 法, 可 以 在 枚 举 值 的 值 中 实 现 抽 象 方 法 枚 举 值 就 是 枚 举 的 对 象, 枚 举 默 认 是 final, 枚 举 值 可 以 隐 含 的 匿 名 内 部 类 来 实 现 枚 举 中 定 义 抽 象 方 法 ( 2 ) 枚 举 类 (Enumeration Classes) 和 类 一 样, 具 有 类 所 有 特 性 Season2 的 父 类 是 java.lang.enum; 隐 含 方 法 : 每 个 枚 举 类 型 都 有 的 方 法 Season2[] ss=season2.values(); for(season2 s:ss){ ---- 获 得 所 有 的 枚 举 值 System.out.println(s.name()); 打 印 枚 举 值 System.out.println(s.ordinal()); 打 印 枚 举 值 的 编 号 (3) enum 可 以 switch 中 使 用 ( 不 加 类 名 )

67 switch( s ){ case SPRING: case SUMMER:.... (4) 枚 举 的 有 参 构 造 enum Season2{ SPRING( 春 ), 逗 号 SUMMER( 夏 ), 逗 号 AUTUMN( 秋 ), 逗 号 WINTER( 冬 ); 分 号 private String name; Season2(String name){ this.name=name; String getname(){ return name; // 构 造 方 法 必 须 是 私 有 的, 可 以 不 写 private, 默 认 就 是 私 有 的 Season2.SPRING.getName() 春 (5) 枚 举 中 定 义 的 抽 象 方 法, 由 枚 举 值 实 现 : enum Operation{ ADD('+'){ public double calculate(double s1,double s2){, return s1+s2; SUBSTRACT('-'){ public double calculate(double s1,double s2){, return s1-s2; MULTIPLY('*'){ public double calculate(double s1,double s2){, return s1*s2;

68 DIVIDE('/'){ public double calculate(double s1,double s2){ ; char name; return s1/s2; public char getname(){ return this.name; Operation(char name){ this.name=name; public abstract double calculate(double s1,double s2); 有 抽 象 方 法 枚 举 元 素 必 须 实 现 该 方 法 Operator[] os = Operator.values(); for(operator o:os){ System.out.println("8 "+o.name()+" 2="+o.calculate(8,2)); for(operator o:os){ System.out.println("8 "+o.getname()+" 2="+o.calculate(8,2)); 运 行 结 果 : 8 ADD 2= SUBSTRACT 2=6.0 8 MULTIPLY 2= DIVIDE 2= = =6.0 8 * 2= / 2=4.0 2 泛 型 (1) 增 强 了 java 的 类 型 安 全, 可 以 在 编 译 期 间 对 容 器 内 的 对 象 进 行 类 型 检 查, 在 运 行 期 不 必 进 行 类 型 的 转 换 而 在 java se5.0 之 前 必 须 在 运 行 期 动 态 进 行 容 器 内 对 象 的 检 查 及 转 换, 泛 型 是 编 译 时 概 念, 运 行 时 没 有 泛 型 减 少 含 糊 的 容 器, 可 以 定 义 什 么 类 型 的 数 据 放 入 容 器 (2)List<Integer> alist = new ArrayList<Integer>();

69 alist.add(new Integer(1)); //... Integer myinteger = alist.get(0); // 从 集 合 中 得 到 的 元 素 不 必 强 制 类 型 转 换 支 持 泛 型 的 集 合, 只 能 存 放 制 定 的 类 型, 或 者 是 指 定 类 型 的 子 类 型 HashMap<String,Float> hm = new HashMap<String,Float>(); 不 能 使 用 原 始 类 型 GenList<int> nlist = new GenList<int>(); // 编 译 错 误 编 译 类 型 的 泛 型 和 运 行 时 类 型 的 泛 型 一 定 要 一 致 没 有 多 态 List<Dog> as = new ArrayList<Dog>(); List<Animal> l = as; //error Animal 与 Dog 的 父 子 关 系 不 能 推 导 出 List<Animal> 与 List<Dog> 之 间 的 父 子 类 关 系 (3) 泛 型 的 通 配 符 "?"? 是 可 以 用 任 意 类 型 替 代 <?> 泛 型 通 配 符 表 示 任 意 类 型 <? extends 类 型 > 表 示 这 个 类 型 是 某 个 类 型 或 接 口 的 子 类 型 <? super 类 型 > 表 示 这 个 类 型 是 某 个 类 型 的 父 类 型 import java.util.*; import static java.lang.system.*; public class TestTemplate { public static void main(string[] args) { List<Object> l1=new ArrayList<Object>(); 类 的 父 类 List<String> l2=new ArrayList<String>(); List<Number> l3=new ArrayList<Number>(); List<Integer> l4=new ArrayList<Integer>(); List<Double> l5=new ArrayList<Double>(); //Number --- Object 的 子 类, 所 有 封 装 print(l1); print(l2); print(l3); print(l4); print(l5); static void print(list<? extends Number> l){ for(number o:l){ out.println(o); static void print(list<? extends Comparable> l){ // 所 有 Number 及 其 子 类 l3,l4,l5 通 过 // 任 何 一 个 实 现 Comparable

70 接 口 的 类 l2,l4,l5 通 过 static void print(list<? super Number> l){ // 所 有 Number 及 其 父 类 l1,l3 通 过 // "?" 可 以 用 来 代 替 任 何 类 型, 例 如 使 用 通 配 符 来 实 现 print 方 法 public static void print(genlist<?> list){ // 表 示 任 何 一 种 泛 型 (4) 泛 型 方 法 的 定 义 --- 相 当 于 方 法 的 模 版 把 数 组 拷 贝 到 集 合 时, 数 组 的 类 型 一 定 要 和 集 合 的 泛 型 相 同 <...> 定 义 泛 型, 其 中 的 "..." 一 般 用 大 写 字 母 来 代 替, 也 就 是 泛 型 的 命 名, 其 实, 在 运 行 时 会 根 据 实 际 类 型 替 换 掉 那 个 泛 型 在 方 法 的 修 饰 符 和 返 回 值 之 间 定 义 泛 型 <E> void copyarraytolist(e[] os,list<e> lst){ static <E extends Number & Comparable> void copyarraytolist(e[] os,list<e> lst){ // 定 义 泛 型 的 范 围 类 在 前 接 口 在 后 static<e, V extends E> void copyarraytolist(e[] os,list<e> lst){ // 定 义 多 个 泛 型 "super" 只 能 用 在 泛 型 的 通 配 符 上, 不 能 用 在 泛 型 的 定 义 上 import java.util.*; public class TestGenerics3 { public static void main(string[] args) { List<String> l1=new ArrayList<String>(); List<Number> l2=new ArrayList<Number>(); List<Integer> l3=new ArrayList<Integer>(); List<Double> l4=new ArrayList<Double>(); List<Object> l5=new ArrayList<Object>(); String[] s1=new String[10]; Number[] s2=new Number[10]; Integer[] s3=new Integer[10]; Double[] s4=new Double[10]; Object[] s5=new Object[10]; copyfromarray(l1,s1); copyfromarray(l2,s2); copyfromarray(l3,s3); copyfromarray(l4,s4); copyfromarray(l5,s5); // 把 数 组 的 数 据 导 入 到 集 合 中 public static <T extends Number&Comparable> void copyfromarray(list<t> l,t[] os){ for(t o:os){ l.add(o);

71 受 限 泛 型 是 指 类 型 参 数 的 取 值 范 围 是 受 到 限 制 的. extends 关 键 字 不 仅 仅 可 以 用 来 声 明 类 的 继 承 关 系, 也 可 以 用 来 声 明 类 型 参 数 (type parameter) 的 受 限 关 系. 泛 型 定 义 的 时 候, 只 能 使 用 extends 不 能 使 用 super, 只 能 向 下, 不 能 向 上 调 用 时 用 <?> 定 义 时 用 <E> (5) 泛 型 类 的 定 义 类 的 静 态 方 法 不 能 使 用 泛 型, 因 为 泛 型 类 是 在 创 建 对 象 的 时 候 产 生 的 class MyClass<E>{ public void show(e a){ System.out.println(a); public E get(){ return null; 受 限 泛 型 class MyClass <E extends Number>{ public void show(e a){ 3 注 释 4 并 发 四 反 射 reflect 反 射, 在 运 行 时, 动 态 分 析 或 使 用 一 个 类 进 行 工 作 反 射 是 一 套 API, 是 一 种 对 底 层 的 对 象 操 作 技 术 1 类 加 载 类 加 载, 生 成.class 文 件, 保 存 类 的 信 息 类 对 象, 是 一 个 描 述 这 个 类 信 息 的 对 象, 对 虚 拟 机 加 载 类 的 时 候, 就 会 创 建 这 个 类 的 类 对 象 并 加 载 该 对 象 Class, 是 类 对 象 的 类 称 为 类 类 只 有 对 象 才 会 被 加 载 到 虚 拟 机 中 一 个 类 只 会 被 加 载 一 次 2 获 得 类 对 象 的 三 种 方 式 :( 类 对 象 不 用 new 的 方 法 得 到 的 ) 1) 也 可 以 用 类 名.Class, 获 得 这 个 类 的 类 对 象 2) 用 一 类 的 对 象 掉 用 a.getclass(), 得 到 这 个 对 象 的 类 型 的 类 对 象

72 3) 也 可 以 使 用 Class.forName( 类 名 )(Class 类 中 的 静 态 方 法 ), 也 可 以 得 到 这 个 类 的 类 对 象, ( 注 意, 这 里 写 的 类 名 必 须 是 全 限 定 名 ( 全 名 ), 是 包 名 加 类 名,XXX.XXX.XXXX) 强 制 类 加 载, 这 种 方 法 是 经 常 使 用 的 一 个 类 的 类 对 象 是 唯 一 的 在 使 用 Class.forName( 类 名 ) 时, 如 果 使 用 时 写 的 类 名 的 类, 还 没 有 被 加 载, 则 会 加 载 这 个 类 Class c; c.getname(); 返 回 类 名 c.getsuperclass(); 这 个 方 法 是 获 得 这 个 类 的 父 类 的 类 对 象 c.getinterfaces(); 会 获 得 这 个 类 所 实 现 的 接 口, 这 个 方 法 返 回 是 一 个 类 对 象 的 数 组 方 法 对 象 是 类 中 的 方 法 的 信 息 的 描 述 java.lang.reflect.method, 方 法 类 的 对 象 可 以 通 过 类 对 象 的 getmethods() 方 法 获 得, 获 得 的 是 一 个 方 法 对 象 的 数 组, 获 得 类 中 的 定 义 的 所 有 方 法 对 象, 除 了 构 造 方 法 构 造 方 法 对 象, 是 用 来 描 述 构 造 方 法 的 信 息 java.lang.reflect.constructor 构 造 方 法 类 的 对 象 可 以 通 过 类 对 象 的 getconstructors() 方 法 获 得, 获 得 这 个 类 的 所 有 构 造 方 法 对 象 属 性 对 象, 使 用 来 描 述 属 性 的 信 息 java.lang.reflect.field 属 性 类 的 对 象 对 象 可 以 通 过 类 对 象 getfields() 这 个 方 法 是 获 得 所 有 属 性 的 属 性 对 象 作 业 : 1 通 过 运 行 时 命 令 行 参 数 输 入 一 个 类 名, 类 出 类 中 所 有 的 方 法 2 实 现 一 个 带 泛 型 的 堆 栈, 用 来 存 放 Number 3 实 现 一 个 栈, 用 来 存 放 任 意 类 型 方 法 : 遍 历,pop,push, 从 数 组 拷 贝 4 定 义 一 个 枚 举, 枚 举 值 是 课 程, 每 个 枚 举 值 有 个 教 师 姓 名 的 属 性 CoreJava 第 十 八 天 一 反 射 1 获 取 方 法 和 属 性 反 射 可 以 获 取 这 个 类 中 定 义 的 方 法 和 属 性 的 信 息, 简 单 数 据 类 型 在 使 用 反 射 时 要 转 换 成 封 装 类 Class c = Teacher.class; Method m = c.getmethod("mrthod",int.class); 2 通 过 类 对 象 生 成 类 的 对 象 Class c = Teacher.class;

73 Object o = c.newinstance(); 3 通 过 类 对 象 调 用 方 法 //1.get class Object Class c=class.forname("student"); //2.get Constructor object Class[] cs={string.class; Constructor con=c.getconstructor(cs);// 按 照 参 数 表 来 调 用 制 定 构 造 方 法 //3.create object Object[] os={"liucy"; Object o=con.newinstance(os); //4.get method object String methodname="study"; Class[] pcs={string.class; Method m=c.getmethod(methodname,pcs);// 按 照 参 数 表 来 获 得 制 定 的 方 法 对 象 //5.invoke the method Object[] ocs={"ejb"; m.invoke(o,ocs); 二 CoreJava 5.0 的 注 释 1 定 义 :Annotation 描 述 代 码 的 代 码 ( 区 : 描 述 代 码 的 文 字 ) 2 注 释 的 分 类 : 给 机 器 看 给 人 看 的 (1) 标 记 注 释 : 没 有 任 何 属 性 的 注 注 释 名 (2) 单 值 注 释 : 只 有 一 个 属 性 的 注 注 释 名 (value= ) 在 单 值 注 释 中 如 果 只 有 一 个 属 性 且 属 性 名 就 是 value, 则 value= 可 以 省 略 (3) 多 值 注 释 : 有 多 个 属 性 的 注 释 多 值 注 释 又 叫 普 通 注 释 3 内 置 注 释 : (1) Override( 只 能 用 来 注 释 方 法 注 释 名 ( 多 个 属 性 附 值, 中 间 用 逗 号 隔 开 ) 表 示 一 个 方 法 声 明 打 算 重 写 超 类 中 的 另 一 个 方 法 声 明 如 果 方 法 利 用 此 注 释 类 型 进 行 注 解 但 没 有 重 写 超 类 方 法, 则 编 译 器 会 生 成 一 条 错 误 消 息 (2) Deprecated 注 释 的 程 序 元 素, 不 鼓 励 程 序 员 使 用 这 样 的 元 素, 通 常 是 因 为 它 很 危 险 或 存 在 更 好 的 选 择 在 使 用 不 被 赞 成 的 程 序 元 素 或 在 不 被 赞 成 的 代 码 中 执 行 重 写 时, 编 译 器 会 发 出 警 告 (3) SuppressWarnings( 该 注 释 无 效 ) 指 示 应 该 在 注 释 元 素 ( 以 及 包 含 在 该 注 释 元 素 中 的 所 有 程 序 元 素 ) 中 取 消 显 示 指 定 的 编 译 器 警 告 4 自 定 义 注 释 自 定 义 注 释 Test{

74 在 自 定 义 注 释 时, 要 用 注 释 来 注 释 ( 描 述 ) 注 用 来 描 述 ( 注 释 ) 注 释 所 能 够 注 释 的 程 序 员 元 描 述 ( 注 释 ) 注 释 要 保 留 多 久 注 释 的 属 性 类 型 可 以 是 8 种 基 本 类 型 String Enum Annotation 以 及 它 们 的 数 组 5 注 释 的 注 释 :java.lang. annotation 包 中 (1) Target: 指 示 注 释 类 型 所 适 用 的 程 序 元 素 的 种 类 例 :@Target(value = {ElementType.METHOD); 说 明 该 注 释 用 来 修 饰 方 法 (2) Retention : 指 示 注 释 类 型 的 注 释 要 保 留 多 久 如 果 注 释 类 型 声 明 中 不 存 在 Retention 注 释, 则 保 留 策 略 默 认 为 RetentionPolicy.CLASS 例 :Retention(value = {RetentionPolicy.xxx 当 x 为 CLASS 表 示 保 留 到 类 文 件 中, 运 行 时 抛 弃 当 x 为 RUNTIME 表 示 运 行 时 仍 保 留 当 x 为 SOURCE 时 表 示 编 译 后 丢 弃 (3) Documented: 指 示 某 一 类 型 的 注 释 将 通 过 javadoc 和 类 似 的 默 认 工 具 进 行 文 档 化 应 使 用 此 类 型 来 注 释 这 些 类 型 的 声 明 : 其 注 释 会 影 响 由 其 客 户 端 注 释 的 元 素 的 使 用 (4) Inherited: 指 示 注 释 类 型 被 自 动 继 承 如 果 在 注 释 类 型 声 明 中 存 在 Inherited 元 注 释, 并 且 用 户 在 某 一 类 声 明 中 查 询 该 注 释 类 型, 同 时 该 类 声 明 中 没 有 此 类 型 的 注 释, 则 将 在 该 类 的 超 类 中 自 动 查 询 该 注 释 类 型 注 : 在 注 释 中, 一 个 属 性 既 是 属 性 又 是 方 法 标 注 : 描 述 代 码 的 文 字 描 述 代 码 的 代 码 给 编 译 器 看 的 代 码, 作 用 是 规 范 编 译 器 的 语 法 class public String tostring(){ return student ; 注 释 类 型 java.lang 1 标 记 注 释 ( 没 有 属 性 2 单 值 注 注 释 名 注 释 名 (prameter=10)

75 int parameter 特 例 注 释 名 (value= 134 ) 等 价 注 释 名 ( 134 ) 3. 普 通 注 释 ( 多 值 注 释 ) (key1=value, 只 能 放 在 方 法 前 用 于 描 述 过 抑 制 警 ddd, aaa, ccc ) //JVM 还 没 有 实 现 这 个 注 释 三 Java5.0 中 的 并 发 1 所 在 的 包 :Java.util.concurrent 2 重 写 线 程 的 原 因 : (1) 何 一 个 进 程 的 创 建 ( 连 接 ) 和 销 毁 ( 释 放 资 源 ) 的 过 程 都 是 一 个 不 可 忽 视 的 开 销 (2)run 方 法 的 缺 陷 : 没 有 返 回 值, 没 有 抛 例 外 3 对 比 1.4 和 5.0 的 线 程 ExecutorService 取 代 Thread Callable Future 取 代 Runnable Lock 取 代 Synchronized SignalAll await() 取 代 notifyall() 取 代 wait() 三 个 新 加 的 多 线 程 包 Java 5.0 里 新 加 入 了 三 个 多 线 程 包 :java.util.concurrent, java.util.concurrent.atomic, java.util.concurrent.locks. java.util.concurrent 包 含 了 常 用 的 多 线 程 工 具, 是 新 的 多 线 程 工 具 的 主 体 java.util.concurrent.atomic 包 含 了 不 用 加 锁 情 况 下 就 能 改 变 值 的 原 子 变 量, 比 如 说 AtomicInteger 提 供 了 addandget() 方 法 Add 和 Get 是 两 个 不 同 的 操 作, 为 了 保 证 别 的 线 程 不 干 扰, 以 往 的 做 法 是 先 锁 定 共 享 的 变 量, 然 后 在 锁 定 的 范 围 内 进 行 两 步 操 作 但 用 AtomicInteger.addAndGet() 就 不 用 担 心 锁 定 的 事 了, 其 内 部 实 现 保 证 了 这 两 步 操 作 是 在 原 子 量 级 发 生 的, 不 会 被 别 的 线 程 干 扰 java.util.concurrent.locks 包 包 含 锁 定 的 工 具 Callable 和 Future 接 口

76 Executor 接 口 替 代 了 Thread 类, 他 可 以 创 建 定 量 的 和 动 态 以 及 周 期 性 的 线 程 池 ExecutorService 接 口, 线 程 池, 用 来 存 放 线 程 来 节 省 创 建 和 销 毁 资 源 的 消 耗 Callable 是 类 似 于 Runnable 的 接 口, 实 现 Callable 接 口 的 类 和 实 现 Runnable 的 类 都 是 可 被 其 它 线 程 执 行 的 任 务 Callable 和 Runnable 有 几 点 不 同 : Callable 规 定 的 方 法 是 call(), 而 Runnable 规 定 的 方 法 是 run(). Callable 的 任 务 执 行 后 可 返 回 值, 而 Runnable 的 任 务 是 不 能 返 回 值 的 call() 方 法 可 抛 出 异 常, 而 run() 方 法 是 不 能 抛 出 异 常 的 Future 对 象 可 以 获 得 线 程 运 行 的 返 回 值 运 行 Callable 任 务 可 拿 到 一 个 Future 对 象, 通 过 Future 对 象 可 了 解 任 务 执 行 情 况, 可 取 消 任 务 的 执 行, 还 可 获 取 任 务 执 行 的 结 果 //*3 以 下 是 Callable 的 一 个 例 子 : public class DoCallStuff implements Callable{ // *1 private int aint; public DoCallStuff(int aint) { this.aint = aint; public String call() throws Exception { //*2 boolean resultok = false; if(aint == 0){ resultok = true; else if(aint == 1){ while(true){ //infinite loop else { if(resultok){ else { System.out.println("looping..."); Thread.sleep(3000); throw new Exception("Ca llable terminated with Exception!"); return "Task done."; return "Task failed"; *1: 名 为 DoCallStuff 类 实 现 了 Callable,String 将 是 call 方 法 的 返 回 值 类 型 例 子 中 用 了 String, 但 可 以 是 任 何 Java 类 *2: call 方 法 的 返 回 值 类 型 为 String, 这 是 和 类 的 定 义 相 对 应 的 并 且 可 以 抛 出 异 常 *3: call 方 法 可 以 抛 出 异 常, 如 加 重 的 斜 体 字 所 示

77 以 下 是 调 用 DoCallStuff 的 主 程 序 import java.util.concurrent.executionexception; import java.util.concurrent.executorservice; import java.util.concurrent.executors; import java.util.concurrent.future; public class Executor { future2.cancel(true)); public static void main(string[] args){ //*1 DoCallStuff call1 = new DoCallStuff(0); DoCallStuff call2 = new DoCallStuff(1); DoCallStuff call3 = new DoCallStuff(2); //*2 ExecutorService es = Executors.newFixedThreadPool(3); //*3 Future future1 = es.submit(call1); Future future2 = es.submit(call2); Future future3 = es.submit(call3); try { //*4 System.out.println(future1.get()); //*5 Thread.sleep(3000); System.out.println("Thread 2 terminated? :" + //*6 System.out.println(future3.get()); catch (ExecutionException ex) { ex.printstacktrace(); catch (InterruptedException ex) { *1: 定 义 了 几 个 任 务 ex.printstacktrace(); *2: 初 始 了 任 务 执 行 工 具 任 务 的 执 行 框 架 将 会 在 后 面 解 释 *3: 执 行 任 务, 任 务 启 动 时 返 回 了 一 个 Future 对 象, 如 果 想 得 到 任 务 执 行 的 结 果 或 者 是 异 常 可 对 这 个 Future 对 象 进 行 操 作 Future 所 含 的 值 必 须 跟 Callable 所 含 的 值 对 映, 比 如 说 例 子 中 Future 对 印 Callable *4: 任 务 1 正 常 执 行 完 毕,future1.get() 会 返 回 线 程 的 值 *5: 任 务 2 在 进 行 一 个 死 循 环, 调 用 future2.cancel(true) 来 中 止 此 线 程 传 入 的 参 数 标 明 是 否 可 打 断 线 程,true 表 明 可 以 打 断 *6: 任 务 3 抛 出 异 常, 调 用 future3.get() 时 会 引 起 异 常 的 抛 出 运 行 Executor 会 有 以 下 运 行 结 果 : looping...

78 Task done. //*1 looping... looping...//*2 looping... looping... looping... looping... Thread 2 terminated? :true //*3 //*4 java.util.concurrent.executionexception: java.lang.exception: Callable terminated with Exception! at java.util.concurrent.futuretask$sync.innerget(futuretask.java:205) at java.util.concurrent.futuretask.get(futuretask.java:80) at concurrent.executor.main(executor.java:43). *1: 任 务 1 正 常 结 束 *2: 任 务 2 是 个 死 循 环, 这 是 它 的 打 印 结 果 *3: 指 示 任 务 2 被 取 消 *4: 在 执 行 future3.get() 时 得 到 任 务 3 抛 出 的 异 常 lock 接 口 实 现 类 ReentrantLock 我 们 可 以 用 lock 对 象, 来 对 临 界 资 源 加 锁, 只 有 获 得 lock 对 象 才 能 访 问 临 界 资 源, 如 果 没 有 获 得 lock 对 象, 就 会 进 入 lock 对 象 的 锁 池 trylock() 方 法 会 返 回 布 尔 值, 这 个 方 法 是 用 来 判 断 这 个 锁 对 象 是 不 是 已 经 被 线 程 获 取, 如 果 返 回 值 为 true, 则 会 直 接 获 得 这 个 锁 对 象, 如 果 返 回 false, 线 程 不 会 阻 塞 还 会 继 续 运 行 Lock lock=new ReentrantLock(); publci void test(){ try{ lock.lock();// 加 锁...// 需 要 加 锁 的 临 界 资 源 finally{ lock.unlock();// 解 锁 ReadWriteLock 读 写 锁 接 口 ReentrantReadWriteLock 是 ReadWriteLock 的 实 现 类 readlock() 分 配 读 锁, 读 锁 可 以 分 配 多 个 线 程, 但 是 在 分 配 读 锁 后 所 有 读 锁 释 放 前, 写 锁 时 不 能 分 配 的

79 配 Lock writelock() 写 锁 只 能 分 配 给 一 个 线 程, 在 分 配 写 锁 后 写 锁 是 放 前, 读 锁 不 能 被 分 Condition 接 口 和 实 现 类 await() 替 代 了 wait() 方 法 notify(),notifyall() 在 JDK5.0 中 已 经 用 signal(),signalall() 方 法 替 换 掉 了, 在 JDK5.0 中, 可 以 使 用 多 个 等 待 队 来 存 放 等 待 的 线 程, 并 对 线 程 进 行 分 类 Queue 接 口 (Collection 的 子 接 口, 对 列 接 口 ) LinkedList 也 实 现 了 这 个 在 JDK5.0 中 的 新 接 口 Queue, 并 且 这 个 类 自 动 的 实 现 了 生 产 者 和 消 费 者 的 同 步 JDK5.0 的 高 级 同 步 Semaphore 类 ( 信 号 量 ) 也 就 是 可 以 向 线 程 分 配 许 可 证, 指 定 许 可 证 数 量 可 以 实 现 多 线 程 的 同 步 Semaphore s=new Semaphore(4);// 可 以 分 配 4 个 许 可 证, 许 可 证 都 被 分 配 出 去 时, 得 不 到 许 可 证 的 线 程 就 会 阻 塞 acquire() 方 法, 获 得 许 可 证 release() 方 法, 释 放 一 个 许 可 证, 也 有 相 应 的 方 法 指 定 释 放 和 获 得 许 可 证 的 数 量 的 方 法 CountDownLatch 类, CountDownLatch 中 有 个 计 数 器, 访 问 这 个 类 的 对 象 就 会 从 计 数 器 中 减 一,countDown() 方 法 会 将 原 有 的 设 置 的 计 数 器 值 减 一, 当 countdown 计 数 器 为 零 时 会 使 放 所 有 await() 的 线 程 CyclicBarrier 类 CyclicBarrier 和 CountDownLatch 比 较 相 似 CyclicBarrier 在 构 造 时 给 出 线 程 数, 只 有 等 待 的 线 程 数 到 了 构 造 方 法 中 指 定 的 数 量, 当 最 后 一 个 线 程 等 待 后, 所 有 的 线 程 都 会 被 释 放, 这 个 类 是 一 个 多 线 程 汇 合 的 工 具 Exchanger 类, 用 exchange() 方 法 可 以 使 两 个 线 程 间 相 互 交 换 对 象, 在 两 线 程 的 同 步 点, 等 待 第 二 个 线 程 在 同 步 点 时, 交 换 对 象, 并 同 时 被 释 放