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 的 联 系 与 区 别