yyrm8.html

关于java学习的一些基本知识！

            有 的“ 异 常” 情 况。 每 个“ 异 常” 类 型 都是Throwable的 子 类。Throwable有 两 个 直 接 的 子 
            类。 一 类 是Exception，是 用 户 程 序 能 够 捕 捉 到 的“ 异 常” 情 况。 我 们 将 通 过 产 生它 的 
            子 类 来 创 建 自 己 的“ 异 常”。 另 一 类 是Error， 它 定 义 了那 ?copy; 通 常 无 法 捕 捉 到 
            的“ 异 常”。 要 谨 慎 使 用Error子 类，因 为 它 们 通 常 会 导 致 灾 难 性 的 失 败。 
            在Exception中 有 一 个 子类RuntimeException， 它 是 程 序 运 行 时 自 动 地 对 某 ?copy; 
            错 误作 出 反 应 而 产 生 的。 </P>
            <H2 align=center>8.3 不 捕 捉“ 异 常” </H2>
            <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:\&gt;java Exc0 java.lang.arithmeticException: / by zero at 
            Exc0.main(Exc0.java:4) </P>
            <H2 align=center>8.4 try与catch </H2>
            <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>
            <H2 align=center>8.5 多 个catch子 句</H2>
            <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:\&gt;java MultiCatch a = 0 div by 0: 
            java.lang.arithmeticexception: / by zero C:\&gt;java MutiCatch 1 a = 
            1 array index oob: java.lang.ArrayIndexOutOfBoundsException:42 </P>
            <H2 align=center>8.6 try语 句 的 嵌 套 </H2>
            <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>
            <H2 align=center>8.7 throw语 句</H2>
            <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>
            <H2 align=center>8.8 throws语 句 </H2>
            <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:\&gt;java ThrowsDemo inside procedure caught 
            java.lang.IllegalAccessException: demo </P>
            <H2 align=center>8.9 finally </H2>
            <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:\&gt;java FinallyDemo inside procA procA's finally inside procB 
            procB's finally </P>
            <H2 align=center>本 章 小 结 </H2>
            <P>1. “ 异 常” 指 的 是 程 序 运 行 时 出 现 的 非 正 常 情 况。 2. 在“ 异 常” 类 层 次 的 最 上 
            层 的 类 叫Throwable， 它 有 两 个 直 接 的 子类：Exception和Error。 3. Java的“ 异 常” 处 
            理 通 过5个 关 键 词 来 实现：try，catch，throw，throws和finally。 </P></TD>
        <TR>
        <TR>
          <TD bgColor=#f0f0f0 borderColor=#ffffff class=t1 noWrap 
            width="50%"><IMG height=12 src="yyrm8.files/yellow_dot.gif" 
            width=12><A 
            href="http://www.chinajavaworld.net/doc/yyrm/yyrm7.html">上一章</A> </TD>
          <TD bgColor=#f0f0f0 borderColor=#ffffff class=t1 noWrap 
            width="50%"><IMG height=12 src="yyrm8.files/blue_dot.gif" 
            width=12><A 
            href="http://www.chinajavaworld.net/doc/yyrm/yyrm9.html">下一章</A> </TD>
        <TR></TR></TBODY></TABLE></TD></TR></TBODY></TABLE><!--end first table --><!--  start foot -->
<SCRIPT src="yyrm8.files/foot1.js"></SCRIPT>

<SCRIPT src="yyrm8.files/adsindex.js"></SCRIPT>

<SCRIPT src="yyrm8.files/foot2.js"></SCRIPT>
<!--  end foot --></CENTER></BODY></HTML>