【字体：小 大】【关闭窗口】

8.1 基础

Java的\" 异 常\" 处 理 是 通 过5个 关 键 词 来 实 现 的：try, catch, throw, throws和finally。 用try 来 执 行 一 段 程 序， 如 果 出 现\" 异 常\"， 系 统 抛 出（throws?copy; 一 个\" 异 常\"， 你 可 以 通 过 它 的 类 型 来 捕 捉（catch?copy; 它， 或 最 后（finally?copy; 由 缺 省 处 理 器 来 处 理。 下 面 是\" 异 常\" 处 理 程 序 的 基 本 形 式： try { //程 序 块 } catch (ExceptionType1 e) { // 对ExceptionType1的 处 理 } catch (ExceptionType2 e) { // 对ExceptionType2的 处 理 throw(e); //再 抛 出 这 个\" 异 常\" } finally { }

8.2 \"异 常\" 的 类 型

在\" 异 常\" 类 层 次 的 最 上 层 有 一 个 单 独 的 类 叫 做Throwable。 这 个 类 用 来 表 示 所 有 的\" 异 常\" 情 况。 每 个\" 异 常\" 类 型 都 是Throwable的 子 类。Throwable有 两 个 直 接 的 子 类。 一 类 是Exception， 是 用 户 程 序 能 够 捕 捉 到 的\" 异 常\" 情 况。 我 们 将 通 过 产 生 它 的 子 类 来 创 建 自 己 的\" 异 常\"。 另 一 类 是Error， 它 定 义 了 那 ?copy; 通 常 无 法 捕 捉 到 的\" 异 常\"。 要 谨 慎 使 用Error子 类， 因 为 它 们 通 常 会 导 致 灾 难 性 的 失 败。 在Exception中 有 一 个 子 类RuntimeException， 它 是 程 序 运 行 时 自 动 地 对 某 ?copy; 错 误 作 出 反 应 而 产 生 的。

8.3 不 捕 捉\" 异 常\"

\" 异 常\" 对 象 是Java在 运 行 时 对 某 ?copy;\" 异 常\" 情 况 作 出 反 应 而 产 生 的。 例 如， 下 面 这 个 小 程 序 包 含 一 个 整 数 被0除 的\" 异 常\"。
class Exc0 { public static void main(String args[]) { int d = 0; int a = 42/d; } }
当Java执 行 这 个 除 法 时， 由 于 分 母 是0， 就 会 构 造 一 个\" 异 常\" 对 象 来 使 程 序 停 下 来 并 处 理 这 个 错 误 情 况， 在 运 行 时\" 抛 出\"（throw?copy; 这 个\" 异 常\"。 说\" 抛 出\" 是 因 为 它 象 一 个 滚 烫 的 马 铃 薯， 你 必 须 把 它 抓 住 并 立 即 处 理。 程 序 流 将 会 在 除 号 操 作 符 处 被 打 断， 然 后 检 查 当 前 的 调 用 堆 栈 来 查 找\" 异 常\"。 一 个\" 异 常\" 处 理 器 是 用 来 立 即 处 理\" 异 常\" 情 况 的。 在 这 个 例 子 里， 我 们 没 有 编 一 个\" 异 常\" 处 理 器， 所 以 缺 省 的 处 理 器 就 发 挥 作 用 了。 缺 省 的 处 理 器 打 印Exception的 字 符 ?reg; 值 和 发 生 \" 异 常\" 的 地 点。
下 面 是 我 们 的 小 例 子 的 输 出。
C:\\>java Exc0 java.lang.arithmeticException: / by zero at Exc0.main(Exc0.java:4)

8.4 try与catch

通 常 我 们 希 望 自 己 来 处 理\" 异 常\" 并 继 续 运 行。 可 以 用try来 指 定 一 块 预 防 所 有\" 异 常\" 的 的 程 序。 紧 跟 在try程 序 后 面， 应 包 含 一 个catch子 句 来 指 定 你 想 要 捕 捉 的\" 异 常\" 的 类 型。 例 如， 下 面 的 例 子 是 在 前 面 的 例 子 的 基础上 构 造 的， 但 它 包 含 一 个try程 序 块 和 一 个catch子 句。 class exc1 { public static void main(string args[]) { try { int d = 0; int a = 42 / d; } catch (arithmeticexception e) { system.out.println(\"division by zero\"); } } }

catch子 句 的 目 标 是 解 决\" 异 常\" 情 况， 把 变 量 设 到 合 理 的 状 态， 并 象 没 有 出 错 一 样 继 续 运 行。 如 果 一 个 子 程 序 不 处 理 某 个\" 异 常\"， 则 返 到 上 一 级 处 理， 直 到 最 外 一 级。

8.5 多 个catch子 句

在 某 情 况 下， 同 一 段 程 序 可 能 产 生 不 止 一 种\" 异 常\" 情 况。 你 可 以 放 置 多 个catch子 句， 其 中 每 一 种\" 异 常\" 类 型 都 将 被 检 查， 第 一 个 与 ?reg; 匹 配 的 就 会 被 执 行。 如 果 一 个 类 和 其 子 类 都 有 的 话， 应 把 子 类 放 在 前 面， 否 则 将 永 远 不 会 到 达 子 类。 下 面 是 一 个 有 两 个catch子 句 的 程 序 的 例 子。
class MultiCatch { public static void main(String args[]) { try { int a
= args.length; System.out.println(\"a = \" + a); int b = 42/a; int c[] =
{1}; c[42] = 99; } catch(ArithmeticException e) { System.out.println(\"div
by 0: \" + e); } catch(ArrayIndexOutOfBoundsException e)
{ system.out.println(\"array index oob: \" + e); } } }

如 果 在 程 序 运 行 时 不 跟 参 数， 将 会 引 起 一 个0做 除 数 的\" 异 常\"， 因 为a的 值 为0。 如 果 我 们 提 ?copy; 一 个 命 令 行 参 数， 将 不 会 产 生 这 个\" 异 常\"， 因 为a的 值 大 于0。 但 会 引 起 一 个 ArrayIndexOutOfBoundexception的\" 异 常\"， 因 为 整 型 数 组c的 长 度 是1， 却 给c[42]赋 值。 下 面 是 以 上 两 种 情 况 的 运 行 结 果。
C:\\>java MultiCatch a = 0 div by 0: java.lang.arithmeticexception: / by
zero C:\\>java MutiCatch 1 a = 1 array index oob:
java.lang.ArrayIndexOutOfBoundsException:42

8.6 try语 句 的 嵌 套

你 可 以 在 一 个 成 员 函 数 调 用 的 外 面 写 一 个try语 句， 在 这 个 成 员 函 数 内 部， 写 另 一 个try语 句 保 护 其 他 代 码。 每 当 遇 到 一 个try语 句，\" 异 常\" 的 框 架 就 放 到 堆 栈 上 面， 直 到 所 有 的try语 句 都 完 成。 如 果 下 一 级 的try语 句 没 有 对 某 种\" 异 常\" 进 行 处 理， 堆 栈 就 会 展 开， 直 到 遇 到 有 处 理 这 种\" 异 常\" 的try语 句。 下 面 是 一 个try语 句 嵌 套 的 例 子。

class MultiNest { static void procedure() { try { int c[] = { 1 }: c[42]
= 99; } catch(ArrayIndexOutOfBoundsexception e)
{ System.out.println(\"array index oob: \" + e); } } public static void
main(String args[]) { try { int a = args.length; system.out.println(\"a
= \" + a); int b = 42/a; procedure(); } catch(arithmeticException e)
{ System.out.println(\"div by 0: \" + e); } } }
成 员 函 数procedure里 有 自 己 的try/catch控 制， 所 以main不 用 去 处 理 ArrayIndexOutOfBoundsException。

8.7 throw语 句

throw语 句 用 来 明 确 地 抛 出 一 个\" 异 常\"。 首 先， 你 必 须 得 到 一 个Throwable的 实 例 的 控 制 柄， 通 过 参 数 传 到catch子 句， 或 者 用new操 作 符 来 创 建 一 个。 下 面 是throw语 句 的 通 常 形 式。
throw ThrowableInstance;
程 序 会 在throw语 句 后 立 即 终 止， 它 后 面 的 语 句 执 行 不 到， 然 后 在 包 含 它 的 所 有try块 中 从 里 向 外 寻 找 含 有 与 其 匹 配 的catch子 句 的try块。 下 面 是 一 个 含 有throw语 句 的 例 子。
class ThrowDemo { static void demoproc() { try { throw new NullPointerException(\"de3mo\"); } catch(NullPointerException e) { System.out.println(\"caught inside demoproc\"); throw e; } } public static void main(String args[]) { try { demoproc(); }
catch(NullPointerException e) { system.out.println(\"recaught: \" + e); } } }

8.8 throws语 句

throws用 来 标 明 一 个 成 员 函 数 可 能 抛 出 的 各 种\" 异 常\"。 对 大 多 数Exception子 类 来 说，Java 编 译 器 会 强 迫 你 声 明 在 一 个 成 员 函 数 中 抛 出 的\" 异 常\" 的 类 型。 如 果\" 异 常\" 的 类 型 是Error或 RuntimeException， 或 它 们 的 子 类， 这 个 规 则 不 起 作 用， 因 为 这 ?copy; 在 程 序 的 正 常 部 分 中 是 不 期 待 出 现 的。 如 果 你 想 明 确 地 抛 出 一 个RuntimeException， 你 必 须 用throws语 句 来 声 明 它 的 类 型。 这 就 重 新 定 义 了 成 员 函 数
的 定 义 语 法： type method-name(arg-list) throws exception-list { }
下 面 是 一 段 程 序， 它 抛 出 了 一 个\" 异 常\"， 但 既 没 有 捕 捉 它， 也 没 有 用throws来 声 明。 这 在 编 译 时 将 不 会 通 过。
class ThrowsDemo1 { static void procedure( ) [ System.out.println(\"inside
procedure\"); throw new IllegalAccessException(\"demo\"); } public static
void main(String args[]) { procedure( ); } }
为 了 让 这 个 例 子 编 译 过 去， 我 们 需 要 声 明 成 员 函 数procedure抛 出 了IllegalAccessException， 并 且 在 调 用 它 的 成 员 函 数main里 捕 捉 它。 下 面 是 正 确 的 例 子：
class ThrowsDemo { static void procedure( ) throws IllegalAccessException
{ System.out.println(\"inside procedure\"); throw new
IllegalAccessException(\"demo\"); } public static void main(String args[])
{ try { procedure( ); } catch (IllegalAccessException e)
{ System.out.println(\"caught \" + e); } } }
下 面 是 输 出 结 果：
C:\\>java ThrowsDemo inside procedure caught
java.lang.IllegalAccessException: demo

8.9 finally

当 一 个\" 异 常\" 被 抛 出 时， 程 序 的 执 行 就 不 再 是 线 性 的， 跳 过 某 ?copy; 行， 甚 至 会 由 于 没 有 与 ?reg; 匹 配 的catch子 句 而 过 早 地 返 回。 有 时 确 保 一 段 代 码 不 管 发 生 什 么\" 异 常\" 都 被 执 行 到 是 必 要 的， 关 键 词finally就 是 用 来 标 识 这 样 一 段 代 码 的。 即 使 你 没 有catch子 句，finally程 序 块 也 会 在 执 行 try程 序 块 后 的 程 序 ?reg; 前 执 行。 每 个try语 句 都 需 要 至 少 一 个 与 ?reg; 相 配 的catch子 句 或finally子 句。 一 个 成 员 函 数 返 回 到 调 用 它 的 成 员 函 数， 或 者 通 过 一 个 没 捕 捉 到 的\" 异 常\"， 或 者 通 过 一 个 明 确 的return语 句，finally子 句 总 是 恰 好 在 成 员 函 数 返 回 前 执 行。 下 面 是 一 个 例 子， 它 有 几 个 成 员 函 数， 每 个 成 员 函 数 用 不 同 的 途 径 退 出， 但 执 行 了finally子 句。
class FinallyDemo { static void procA( ) { try
{ System.out.println(\"inside procA\"); throw new
RuntimeException(\"demo\"); } finally { System.out.println(\"procA\'s
finally\"); } } static void procB( ) { try { System.out.println(\"inside
procB\"); return; } finally { System.out.println(\"procB\'s finally\"); } }
public static void main(String args[]) { try { procA( ); } catch (Exception
e); procB( ); } }
下 面 是 这 个 例 子 的 运 行 结 果：
C:\\>java FinallyDemo inside procA procA\'s finally inside procB procB\'s finally

本 章 小 结

1. \" 异 常\" 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 2. 在\" 异 常\" 类 层 次 的 最 上 层 的 类 叫Throwable， 它 有 两 个 直 接 的 子 类：Exception和Error。 3. Java的\" 异 常\" 处 理 通 过5个 关 键 词 来 实 现：try，catch，throw，throws和finally。