解析Java中未被捕获的异常以及try语句的嵌套使用

java未被捕获的异常
在你学习在程序中处理异常之前，看一看如果你不处理它们会有什么情况发生是很有好处的。下面的小程序包括一个故意导致被零除错误的表达式。

class exc0 {
  public static void main(string args[]) {
    int d = 0;
    int a = 42 / d;
  }
}

当java运行时系统检查到被零除的情况，它构造一个新的异常对象然后抛出该异常。这导致exc0的执行停止，因为一旦一个异常被抛出，它必须被一个异常处理程序捕获并且被立即处理。该例中，我们没有提供任何我们自己的异常处理程序，所以异常被java运行时系统的默认处理程序捕获。任何不是被你程序捕获的异常最终都会被该默认处理程序处理。默认处理程序显示一个描述异常的字符串，打印异常发生处的堆栈轨迹并且终止程序。

下面是由标准javajdk运行时解释器执行该程序所产生的输出：

  java.lang.arithmeticexception: / by zero
  at exc0.main(exc0.java:4)

注意，类名exc0，方法名main，文件名exc0.java和行数4是怎样被包括在一个简单的堆栈使用轨迹中的。还有，注意抛出的异常类型是exception的一个名为arithmeticexception的子类，该子类更明确的描述了何种类型的错误方法。本章后面部分将讨论，java提供多个内置的与可能产生的不同种类运行时错误相匹配的异常类型。

堆栈轨迹将显示导致错误产生的方法调用序列。例如，下面是前面程序的另一个版本，它介绍了相同的错误，但是错误是在main( )方法之外的另一个方法中产生的：

class exc1 {
  static void subroutine() {
    int d = 0;
    int a = 10 / d;
  }
  public static void main(string args[]) {
    exc1.subroutine();
  }
}

默认异常处理器的堆栈轨迹结果表明了整个调用栈是怎样显示的：

  java.lang.arithmeticexception: / by zero
  at exc1.subroutine(exc1.java:4)
  at exc1.main(exc1.java:7)

如你所见，栈底是main的第7行，该行调用了subroutine( )方法。该方法在第4行导致了异常。调用堆栈对于调试来说是很重要的，因为它查明了导致错误的精确的步骤。

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

// an example of nested try statements.
class nesttry {
  public static void main(string args[]) {
    try {
      int a = args.length;
      /* if no command-line args are present,the following statement will generate a divide-by-zero exception. */
      int b = 42 / a;
      system.out.println("a = " + a);
      try { // nested try block
        /* if one command-line arg is used,then a divide-by-zero exception will be generated by the following code. */
        if(a==1) a = a/(a-a); // division by zero
        /* if two command-line args are used,then generate an out-of-bounds exception. */
        if(a==2) {
          int c[] = { 1 };
          c[42] = 99; // generate an out-of-bounds exception
        }
      } catch(arrayindexoutofboundsexception e) {
        system.out.println("array index out-of-bounds: " + e);
      }
    } catch(arithmeticexception e) {
      system.out.println("divide by 0: " + e);
    }
  }
}

如你所见，该程序在一个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( )的内部：

/* try statements can be implicitly nested via calls to methods. */
class methnesttry {
  static void nesttry(int a) {
    try { // nested try block
      /* if one command-line arg is used,then a divide-by-zero exception will be generated by the following code. */
      if(a==1) a = a/(a-a); // division by zero
      /* if two command-line args are used,then generate an out-of-bounds exception. */
      if(a==2) {
        int c[] = { 1 };
        c[42] = 99; // generate an out-of-bounds exception
      }
    } catch(arrayindexoutofboundsexception e) {
      system.out.println("array index out-of-bounds: " + e);
    }
  }

  public static void main(string args[]) {
    try {
      int a = args.length;
      /* if no command-line args are present,the following statement will generate a divide-by-zero exception. */
      int b = 42 / a;
      system.out.println("a = " + a);
      nesttry(a);
    } catch(arithmeticexception e) {
      system.out.println("divide by 0: " + e);
    }
  }
}

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