[JAVA语言入门] 第八章Java的异常

发布时间:2010年04月28日      浏览次数:321 次
“异常” 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 在 用 传 统 的 语 言 编 程 时, 程 序 员 只 能 通 过 函 数 的 返 回 值 来 发 出 错 误 信 息。 这 易 于 导 致 很 多 错 误, 因 为 在 很 多 情 况 下 需 要 知 道 错 误 产 生 的 内 部 细 节。 通 常, 用 全 局 变 量errno来 存 储“异常” 的 类 型。 这 容 易 导 致 误 用, 因 为 一 个errno的 值 有 可 能 在 被 处 理 ?reg; 前 被 另 外 的 错 误 覆 盖 掉。 即 使 最 优 美 的C语 言 程 序, 为 了 处 理“异常” 情 况, 也 常 求 助 于goto语 句。 Java对“异常” 的 处 理 是 面 向 对 象 的。 一 个Java的Exception是 一 个 描 述“异常” 情 况 的 对 象。 当 出 现“异常” 情 况 时, 一 个Exception对 象 就 产 生 了, 并 放 到 产 生 这 个“异常” 的 成 员 函 数 里。
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。
免责声明:本站相关技术文章信息部分来自网络,目的主要是传播更多信息,如果您认为本站的某些信息侵犯了您的版权,请与我们联系,我们会即时妥善的处理,谢谢合作!