Java知多少(48)try语句的嵌套

Try语句可以被嵌套。也就是说,一个try语句可以在另一个try块内部。每次进入try语句,异常的前后关系都会被推入堆栈。如果一个内部的try语句不含特殊异常的catch处理程序,堆栈将弹出,下一个try语句的catch处理程序将检查是否与之匹配。这个过程将继续直到一个catch语句匹配成功,或者是直到所有的嵌套try语句被检查耗尽。如果没有catch语句匹配,Java的运行时系统将处理这个异常。下面是运用嵌套try语句的一个例子:

 1 // An example of nested try statements.
 2 class NestTry {
 3     public static void main(String args[]) {
 4         try {
 5             int a = args.length;
 6             /* If no command-line args are present,the following statement will generate a divide-by-zero exception. */
 7             int b = 42 / a;
 8             System.out.println("a = " + a);
 9             try { // nested try block
10                 /* If one command-line arg is used,then a divide-by-zero exception will be generated by the following code. */
11                 if(a==1) a = a/(a-a); // division by zero
12                 /* If two command-line args are used,then generate an out-of-bounds exception. */
13                 if(a==2) {
14                     int c[] = { 1 };
15                     c[42] = 99; // generate an out-of-bounds exception
16                 }
17             } catch(ArrayIndexOutOfBoundsException e) {
18                 System.out.println("Array index out-of-bounds: " + e);
19             }
20         } catch(ArithmeticException e) {
21             System.out.println("Divide by 0: " + e);
22         }
23     }
24 }

如你所见,该程序在一个try块中嵌套了另一个try块。程序工作如下:当你在没有命令行参数的情况下执行该程序,外面的try块将产生一个被零除的异常。程序在有一个命令行参数条件下执行,由嵌套的try块产生一个被零除的错误。因为内部的块不匹配这个异常,它将把异常传给外部的try块,在那里异常被处理。如果你在具有两个命令行参数的条件下执行该程序,由内部try块产生一个数组边界异常。下面的结果阐述了每一种情况:

C:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One
a = 1
Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One Two
a = 2
Array index out-of-bounds: java.lang.ArrayIndexOutOfBoundsException

当有方法调用时,try语句的嵌套可以很隐蔽的发生。例如,你可以把对方法的调用放在一个try块中。在该方法内部,有另一个try语句。这种情况下,方法内部的try仍然是嵌套在外部调用该方法的try块中的。下面是前面例子的修改,嵌套的try块移到了方法nesttry( )的内部:

 1 /* Try statements can be implicitly nested via calls to methods. */
 2 class MethNestTry {
 3     static void nesttry(int a) {
 4         try { // nested try block
 5             /* If one command-line arg is used,then a divide-by-zero exception will be generated by the following code. */
 6             if(a==1) a = a/(a-a); // division by zero
 7             /* If two command-line args are used,then generate an out-of-bounds exception. */
 8             if(a==2) {
 9                 int c[] = { 1 };
10                 c[42] = 99; // generate an out-of-bounds exception
11             }
12         } catch(ArrayIndexOutOfBoundsException e) {
13             System.out.println("Array index out-of-bounds: " + e);
14         }
15     }
16
17     public static void main(String args[]) {
18         try {
19             int a = args.length;
20            /* If no command-line args are present,the following statement will generate a divide-by-zero exception. */
21            int b = 42 / a;
22            System.out.println("a = " + a);
23            nesttry(a);
24         } catch(ArithmeticException e) {
25             System.out.println("Divide by 0: " + e);
26         }
27     }
28 }

该程序的输出与前面的例子相同。

系列文章:

Java知多少(上)

Java知多少(39)interface接口

Java知多少(40)接口和抽象类的区别

Java知多少(41)泛型详解

Java知多少(42)泛型通配符和类型参数的范围

Java知多少(43)异常处理基础

Java知多少(44)异常类型

Java知多少(45)未被捕获的异常

Java知多少(46)try和catch的使用

Java知多少(47)多重catch语句的使用

时间: 2024-08-24 05:08:55

Java知多少(48)try语句的嵌套的相关文章

Java知多少(47)多重catch语句的使用

某些情况,由单个代码段可能引起多个异常.处理这种情况,你可以定义两个或更多的catch子句,每个子句捕获一种类型的异常.当异常被引发时,每一个catch子句被依次检查,第一个匹配异常类型的子句执行.当一个catch语句执行以后,其他的子句被旁路,执行从try/catch块以后的代码开始继续.下面的例子设计了两种不同的异常类型: 1 // Demonstrate multiple catch statements. 2 class MultiCatch { 3 public static void

Java基础---Java条件语句之嵌套if(二十)

Java条件语句之嵌套 if 嵌套 if 语句,只有当外层 if 的条件成立时,才会判断内层 if 的条件.例如,活动计划的安排,如果今天是工作日,则去上班,如果今天是周末,则外出游玩:同时,如果周末天气晴朗,则去室外游乐场游玩,否则去室内游乐场游玩. 语法:  执行过程:  例如: 运行结果: 代码: public class Helloworld {            public static void main(String[] args) {          int score

Java知多少(完结篇)

Java知多少(1)语言概述 Java知多少(2)虚拟机(JVM)以及跨平台原理 Java知多少(3) 就业方向 Java知多少(4)J2SE.J2EE.J2ME的区别 Java知多少(5) Java开发环境的搭建 Java知多少(6)第一个程序示例 Java知多少(7)类与对象 Java知多少(8)类库及其组织结构 Java知多少(9) import及Java类的搜索路径 Java知多少(10)数据类型及变量 Java知多少(11)数据类型转换 Java知多少(12)运算符 Java知多少(1

Java知多少(53)使用Java创建自己的异常子类

尽管Java的内置异常处理大多数常见错误,你也许希望建立你自己的异常类型来处理你所应用的特殊情况.这是非常简单的:只要定义Exception的一个子类就可以了(Exception当然是Throwable的一个子类).你的子类不需要实际执行什么——它们在类型系统中的存在允许你把它们当成异常使用. Exception类自己没有定义任何方法.当然,它继承了Throwable提供的一些方法.因此,所有异常,包括你创建的,都可以获得Throwable定义的方法.这些方法显示在表10-3中.你还可以在你创建

Java知多少(52)内置异常

在标准包java.lang中,Java定义了若干个异常类.前面的例子曾用到其中一些.这些异常一般是标准类RuntimeException的子类.因为java.lang实际上被所有的Java程序引入,多数从RuntimeException派生的异常都自动可用.而且,它们不需要被包含在任何方法的throws列表中.Java语言中,这被叫做未经检查的异常(unchecked exceptions ).因为编译器不检查它来看一个方法是否处理或抛出了这些异常. java.lang中定义的未经检查的异常列于

Java知多少(51)finally

当异常被抛出,通常方法的执行将作一个陡峭的非线性的转向.依赖于方法是怎样编码的,异常甚至可以导致方法过早返回.这在一些方法中是一个问题.例如,如果一个方法打开一个文件项并关闭,然后退出,你不希望关闭文件的代码被异常处理机制旁路.finally关键字为处理这种意外而设计. finally创建一个代码块.该代码块在一个try/catch 块完成之后另一个try/catch出现之前执行.finally块无论有没有异常抛出都会执行.如果异常被抛出,finally甚至是在没有与该异常相匹配的catch子句

Java知多少(50)Java throws子句

如果一个方法可以导致一个异常但不处理它,它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常.做到这点你可以在方法声明中包含一个throws子句.一个 throws 子句列举了一个方法可能抛出的所有异常类型.这对于除Error或RuntimeException及它们子类以外类型的所有异常是必要的.一个方法可以抛出的所有其他类型的异常必须在throws子句中声明.如果不这样做,将会导致编译错误. 下面是包含一个throws子句的方法声明的通用形式: 1 type method-name(

Java知多少(57)主线程

当Java程序启动时,一个线程立刻运行,该线程通常叫做程序的主线程(main thread),因为它是程序开始时就执行的.主线程的重要性体现在两方面: 它是产生其他子线程的线程: 通常它必须最后完成执行,因为它执行各种关闭动作. 尽管主线程在程序启动时自动创建,但它可以由一个Thread对象控制.为此,你必须调用方法currentThread()获得它的一个引用,currentThread()是Thread类的公有的静态成员.它的通常形式如下:    static Thread currentT

Java知多少(54)断言详解

断言的概念 断言用于证明和测试程序的假设,比如“这里的值大于 5”.断言可以在运行时从代码中完全删除,所以对代码的运行速度没有影响. 断言的使用 断言有两种方法: 一种是 assert<<布尔表达式>> : 另一种是 assert<<布尔表达式>> :<<细节描述>>. 如果布尔表达式的值为false , 将抛出AssertionError 异常: 细节描述是AssertionError异常的描述文本使用 javac –source