📄 0061.htm
字号:
<html>
<head>
<title>新时代软件教程:操作系统 主页制作 服务器 设计软件 网络技术 编程语言 文字编辑</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<style>
<!--
body, table {font-size: 9pt; font-family: 宋体}
a {text-decoration:none}
a:hover {color: red;text-decoration:underline}
.1 {background-color: rgb(245,245,245)}
-->
</style>
</head>
<p align="center"><script src="../../1.js"></script></a>
<p align="center"><big><strong>第八章 Java的“异常”</strong></big></p>
<div align="right">---（文/刘春阳）</div>
<p>“ 异 常” 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 在 用 传
统 的 语 言 编 程 时， 程 序 员 只 能 通 过 函 数 的 返 回 值 来 发 出
错 误 信 息。 这 易 于 导 致 很 多 错 误， 因 为 在 很 多 情 况 下 需 要
知 道 错 误 产 生 的 内 部 细 节。 通 常， 用 全 局 变 量errno来 存 储“
异 常” 的 类 型。 这 容 易 导 致 误 用， 因 为 一 个errno的 值 有 可 能
在 被 处 理 ?reg; 前 被 另 外 的 错 误 覆 盖 掉。 即 使 最 优 美 的C语
言 程 序， 为 了 处 理“ 异 常” 情 况， 也 常 求 助 于goto语 句。 Java对“
异 常” 的 处 理 是 面 向 对 象 的。 一 个Java的Exception是 一 个 描 述“
异 常” 情 况 的 对 象。 当 出 现“ 异 常” 情 况 时， 一 个Exception对
象 就 产 生 了， 并 放 到 产 生 这 个“ 异 常” 的 成 员 函 数 里。 </p>
<h4 align=center>8.1 基础 </h4>
<p>Java的“ 异 常” 处 理 是 通 过5个 关 键 词 来 实 现 的：try, catch,
throw, throws和finally。 用try 来 执 行 一 段 程 序， 如 果 出 现“ 异
常”， 系 统 抛 出（throws?copy; 一 个“ 异 常”， 你 可 以 通 过 它 的
类 型 来 捕 捉（catch?copy; 它， 或 最 后（finally?copy; 由 缺 省 处
理 器 来 处 理。 下 面 是“ 异 常” 处 理 程 序 的 基 本 形 式： </p>
<p>try { //程 序 块 } catch (ExceptionType1 e) { // 对ExceptionType1的
处 理 } catch (ExceptionType2 e) { // 对ExceptionType2的 处 理 throw(e);
//再 抛 出 这 个“ 异 常” } finally { } </p>
<h4 align=center>8.2 "异 常” 的 类 型</h4>
<p>在“ 异 常” 类 层 次 的 最 上 层 有 一 个 单 独 的 类 叫 做Throwable。
这 个 类 用 来 表 示 所 有 的“ 异 常” 情 况。 每 个“ 异 常” 类 型 都
是Throwable的 子 类。Throwable有 两 个 直 接 的 子 类。 一 类 是Exception，
是 用 户 程 序 能 够 捕 捉 到 的“ 异 常” 情 况。 我 们 将 通 过 产 生
它 的 子 类 来 创 建 自 己 的“ 异 常”。 另 一 类 是Error， 它 定 义 了
那 ?copy; 通 常 无 法 捕 捉 到 的“ 异 常”。 要 谨 慎 使 用Error子 类，
因 为 它 们 通 常 会 导 致 灾 难 性 的 失 败。 在Exception中 有 一 个 子
类RuntimeException， 它 是 程 序 运 行 时 自 动 地 对 某 ?copy; 错 误
作 出 反 应 而 产 生 的。 </p>
<h4 align=center>8.3 不 捕 捉“ 异 常” </h4>
<p>“ 异 常” 对 象 是Java在 运 行 时 对 某 ?copy;“ 异 常” 情 况 作
出 反 应 而 产 生 的。 例 如， 下 面 这 个 小 程 序 包 含 一 个 整 数 被0除
的“ 异 常”。 </p>
<p>class Exc0 { public static void main(String args[]) { int d = 0; int
a = 42/d; } } </p>
<p>当Java执 行 这 个 除 法 时， 由 于 分 母 是0， 就 会 构 造 一 个“ 异
常” 对 象 来 使 程 序 停 下 来 并 处 理 这 个 错 误 情 况， 在 运 行 时“
抛 出”（throw?copy; 这 个“ 异 常”。 说“ 抛 出” 是 因 为 它 象 一
个 滚 烫 的 马 铃 薯， 你 必 须 把 它 抓 住 并 立 即 处 理。 程 序 流 将
会 在 除 号 操 作 符 处 被 打 断， 然 后 检 查 当 前 的 调 用 堆 栈 来
查 找“ 异 常”。 一 个“ 异 常” 处 理 器 是 用 来 立 即 处 理“ 异 常”
情 况 的。 在 这 个 例 子 里， 我 们 没 有 编 一 个“ 异 常” 处 理 器，
所 以 缺 省 的 处 理 器 就 发 挥 作 用 了。 缺 省 的 处 理 器 打 印Exception的
字 符 ?reg; 值 和 发 生 “ 异 常” 的 地 点。 下 面 是 我 们 的 小 例
子 的 输 出。 </p>
<p>C:\>java Exc0 java.lang.arithmeticException: / by zero at Exc0.main(Exc0.java:4)
</p>
<h4 align=center>8.4 try与catch </h4>
<p>通 常 我 们 希 望 自 己 来 处 理“ 异 常” 并 继 续 运 行。 可 以 用try来
指 定 一 块 预 防 所 有“ 异 常” 的 的 程 序。 紧 跟 在try程 序 后 面，
应 包 含 一 个catch子 句 来 指 定 你 想 要 捕 捉 的“ 异 常” 的 类 型。
例 如， 下 面 的 例 子 是 在 前 面 的 例 子 的 基础上 构 造 的， 但 它
包 含 一 个try程 序 块 和 一 个catch子 句。 </p>
<p>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"); } } } </p>
<p>catch子 句 的 目 标 是 解 决“ 异 常” 情 况， 把 一 ?copy; 变 量 设
到 合 理 的 状 态， 并 象 没 有 出 错 一 样 继 续 运 行。 如 果 一 个 子
程 序 不 处 理 某 个“ 异 常”， 则 返 到 上 一 级 处 理， 直 到 最 外
一 级。 </p>
<h4 align=center>8.5 多 个catch子 句</h4>
<p>在 某 ?copy; 情 况 下， 同 一 段 程 序 可 能 产 生 不 止 一 种“ 异
常” 情 况。 你 可 以 放 置 多 个catch子 句， 其 中 每 一 种“ 异 常”
类 型 都 将 被 检 查， 第 一 个 与 ?reg; 匹 配 的 就 会 被 执 行。 如
果 一 个 类 和 其 子 类 都 有 的 话， 应 把 子 类 放 在 前 面， 否 则 将
永 远 不 会 到 达 子 类。 下 面 是 一 个 有 两 个catch子 句 的 程 序 的
例 子。 </p>
<p>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); } } } </p>
<p>如 果 在 程 序 运 行 时 不 跟 参 数， 将 会 引 起 一 个0做 除 数 的“
异 常”， 因 为a的 值 为0。 如 果 我 们 提 ?copy; 一 个 命 令 行 参 数，
将 不 会 产 生 这 个“ 异 常”， 因 为a的 值 大 于0。 但 会 引 起 一 个
ArrayIndexOutOfBoundexception的“ 异 常”， 因 为 整 型 数 组c的 长 度
是1， 却 给c[42]赋 值。 下 面 是 以 上 两 种 情 况 的 运 行 结 果。 </p>
<p>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
</p>
<h4 align=center>8.6 try语 句 的 嵌 套 </h4>
<p>你 可 以 在 一 个 成 员 函 数 调 用 的 外 面 写 一 个try语 句， 在 这
个 成 员 函 数 内 部， 写 另 一 个try语 句 保 护 其 他 代 码。 每 当 遇
到 一 个try语 句，“ 异 常” 的 框 架 就 放 到 堆 栈 上 面， 直 到 所 有
的try语 句 都 完 成。 如 果 下 一 级 的try语 句 没 有 对 某 种“ 异 常”
进 行 处 理， 堆 栈 就 会 展 开， 直 到 遇 到 有 处 理 这 种“ 异 常”
的try语 句。 下 面 是 一 个try语 句 嵌 套 的 例 子。 </p>
<p>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); } } } </p>
<p>成 员 函 数procedure里 有 自 己 的try/catch控 制， 所 以main不 用 去
处 理 ArrayIndexOutOfBoundsException。 </p>
<h4 align=center>8.7 throw语 句</h4>
<p>throw语 句 用 来 明 确 地 抛 出 一 个“ 异 常”。 首 先， 你 必 须 得
到 一 个Throwable的 实 例 的 控 制 柄， 通 过 参 数 传 到catch子 句， 或
者 用new操 作 符 来 创 建 一 个。 下 面 是throw语 句 的 通 常 形 式。 </p>
<p>throw ThrowableInstance; </p>
<p>程 序 会 在throw语 句 后 立 即 终 止， 它 后 面 的 语 句 执 行 不 到，
然 后 在 包 含 它 的 所 有try块 中 从 里 向 外 寻 找 含 有 与 其 匹 配
的catch子 句 的try块。 下 面 是 一 个 含 有throw语 句 的 例 子。 </p>
<p>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); } } } </p>
<h4 align=center>8.8 throws语 句 </h4>
<p>throws用 来 标 明 一 个 成 员 函 数 可 能 抛 出 的 各 种“ 异 常”。
对 大 多 数Exception子 类 来 说，Java 编 译 器 会 强 迫 你 声 明 在 一
个 成 员 函 数 中 抛 出 的“ 异 常” 的 类 型。 如 果“ 异 常” 的 类 型
是Error或 RuntimeException， 或 它 们 的 子 类， 这 个 规 则 不 起 作 用，
因 为 这 ?copy; 在 程 序 的 正 常 部 分 中 是 不 期 待 出 现 的。 如 果
你 想 明 确 地 抛 出 一 个RuntimeException， 你 必 须 用throws语 句 来
声 明 它 的 类 型。 这 就 重 新 定 义 了 成 员 函 数 的 定 义 语 法： </p>
<p>type method-name(arg-list) throws exception-list { } </p>
<p>下 面 是 一 段 程 序， 它 抛 出 了 一 个“ 异 常”， 但 既 没 有 捕
捉 它， 也 没 有 用throws来 声 明。 这 在 编 译 时 将 不 会 通 过。 </p>
<p>class ThrowsDemo1 { static void procedure( ) [ System.out.println("inside
procedure"); throw new IllegalAccessException("demo"); }
public static void main(String args[]) { procedure( ); } } </p>
<p>为 了 让 这 个 例 子 编 译 过 去， 我 们 需 要 声 明 成 员 函 数procedure抛
出 了IllegalAccessException， 并 且 在 调 用 它 的 成 员 函 数main里 捕
捉 它。 下 面 是 正 确 的 例 子： </p>
<p>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);
} } } </p>
<p>下 面 是 输 出 结 果： </p>
<p>C:\>java ThrowsDemo inside procedure caught java.lang.IllegalAccessException:
demo </p>
<h4 align=center>8.9 finally </h4>
<p>当 一 个“ 异 常” 被 抛 出 时， 程 序 的 执 行 就 不 再 是 线 性 的，
跳 过 某 ?copy; 行， 甚 至 会 由 于 没 有 与 ?reg; 匹 配 的catch子 句
而 过 早 地 返 回。 有 时 确 保 一 段 代 码 不 管 发 生 什 么“ 异 常”
都 被 执 行 到 是 必 要 的， 关 键 词finally就 是 用 来 标 识 这 样 一
段 代 码 的。 即 使 你 没 有catch子 句，finally程 序 块 也 会 在 执 行
try程 序 块 后 的 程 序 ?reg; 前 执 行。 每 个try语 句 都 需 要 至 少
一 个 与 ?reg; 相 配 的catch子 句 或finally子 句。 一 个 成 员 函 数 返
回 到 调 用 它 的 成 员 函 数， 或 者 通 过 一 个 没 捕 捉 到 的“ 异 常”，
或 者 通 过 一 个 明 确 的return语 句，finally子 句 总 是 恰 好 在 成 员
函 数 返 回 前 执 行。 下 面 是 一 个 例 子， 它 有 几 个 成 员 函 数，
每 个 成 员 函 数 用 不 同 的 途 径 退 出， 但 执 行 了finally子 句。 </p>
<p>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( );
} } </p>
<p>下 面 是 这 个 例 子 的 运 行 结 果： </p>
<p>C:\>java FinallyDemo inside procA procA's finally inside procB procB's
finally </p>
<h4 align=center>本 章 小 结 </h4>
<p>1. “ 异 常” 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 2. 在“
异 常” 类 层 次 的 最 上 层 的 类 叫Throwable， 它 有 两 个 直 接 的 子
类：Exception和Error。 3. Java的“ 异 常” 处 理 通 过5个 关 键 词 来 实
现：try，catch，throw，throws和finally。 </p>
</table>
<p align="center"><script src="../../2.js"></script></a>
</body>
</html>⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -