Java中异常处理之try和catch代码块的使用

java try和catch的使用
尽管由java运行时系统提供的默认异常处理程序对于调试是很有用的，但通常你希望自己处理异常。这样做有两个好处。第一，它允许你修正错误。第二，它防止程序自动终止。大多数用户对于在程序终止运行和在无论何时错误发生都会打印堆栈轨迹感到很烦恼（至少可以这么说）。幸运的是，这很容易避免。

为防止和处理一个运行时错误，只需要把你所要监控的代码放进一个try块就可以了。紧跟着try块的，包括一个说明你希望捕获的错误类型的catch子句。完成这个任务很简单，下面的程序包含一个处理因为被零除而产生的arithmeticexception 异常的try块和一个catch子句。

class exc2 {
  public static void main(string args[]) {
    int d, a;
    try { // monitor a block of code.
      d = 0;
      a = 42 / d;
      system.out.println("this will not be printed.");
    } catch (arithmeticexception e) { // catch divide-by-zero error
      system.out.println("division by zero.");
    }
    system.out.println("after catch statement.");
  }
}

该程序输出如下：

division by zero.
after catch statement.

注意在try块中的对println( )的调用是永远不会执行的。一旦异常被引发，程序控制由try块转到catch块。执行永远不会从catch块“返回”到try块。因此，“this will not be printed。”

将不会被显示。一旦执行了catch语句，程序控制从整个try/catch机制的下面一行继续。

一个try和它的catch语句形成了一个单元。catch子句的范围限制于try语句前面所定义的语句。一个catch语句不能捕获另一个try声明所引发的异常（除非是嵌套的try语句情况）。

被try保护的语句声明必须在一个大括号之内（也就是说，它们必须在一个块中）。你不能单独使用try。

构造catch子句的目的是解决异常情况并且像错误没有发生一样继续运行。例如，下面的程序中，每一个for循环的反复得到两个随机整数。这两个整数分别被对方除，结果用来除12345。最后的结果存在a中。如果一个除法操作导致被零除错误，它将被捕获，a的值设为零，程序继续运行。

// handle an exception and move on.
import java.util.random;

class handleerror {
  public static void main(string args[]) {
    int a=0, b=0, c=0;
    random r = new random();

    for(int i=0; i<32000; i++) {
      try {
        b = r.nextint();
        c = r.nextint();
        a = 12345 / (b/c);
      } catch (arithmeticexception e) {
        system.out.println("division by zero.");
        a = 0; // set a to zero and continue
      }
      system.out.println("a: " + a);
    }
  }
}

显示一个异常的描述

throwable重载tostring( )方法（由object定义），所以它返回一个包含异常描述的字符串。你可以通过在println( )中传给异常一个参数来显示该异常的描述。例如，前面程序的catch块可以被重写成

catch (arithmeticexception e) {
  system.out.println("exception: " + e);
  a = 0; // set a to zero and continue
}

当这个版本代替原程序中的版本，程序在标准javajdk解释器下运行，每一个被零除错误显示下面的消息：

  exception: java.lang.arithmeticexception: / by zero

尽管在上下文中没有特殊的值，显示一个异常描述的能力在其他情况下是很有价值的——特别是当你对异常进行实验和调试时。

java 多重catch语句的使用
某些情况，由单个代码段可能引起多个异常。处理这种情况，你可以定义两个或更多的catch子句，每个子句捕获一种类型的异常。当异常被引发时，每一个catch子句被依次检查，第一个匹配异常类型的子句执行。当一个catch语句执行以后，其他的子句被旁路，执行从try/catch块以后的代码开始继续。下面的例子设计了两种不同的异常类型：

// demonstrate multiple catch statements.
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("divide by 0: " + e);
    } catch(arrayindexoutofboundsexception e) {
      system.out.println("array index oob: " + e);
    }
    system.out.println("after try/catch blocks.");
  }
}

该程序在没有命令行参数的起始条件下运行导致被零除异常，因为a为0。如果你提供一个命令行参数，它将幸免于难，把a设成大于零的数值。但是它将导致arrayindexoutof boundsexception异常，因为整型数组c的长度为1，而程序试图给c[42]赋值。

下面是运行在两种不同情况下程序的输出：

c:\>java multicatch
a = 0
divide by 0: java.lang.arithmeticexception: / by zero after try/catch blocks.
c:\>java multicatch testarg
a = 1
array index oob: java.lang.arrayindexoutofboundsexception after try/catch blocks.

当你用多catch语句时，记住异常子类必须在它们任何父类之前使用是很重要的。这是因为运用父类的catch语句将捕获该类型及其所有子类类型的异常。这样，如果子类在父类后面，子类将永远不会到达。而且，java中不能到达的代码是一个错误。例如，考虑下面的程序：

/* this program contains an error.
a subclass must come before its superclass in a series of catch statements. if not,unreachable code will be created and acompile-time error will result.
*/
class supersubcatch {
  public static void main(string args[]) {
    try {
      int a = 0;
      int b = 42 / a;
    } catch(exception e) {
      system.out.println("generic exception catch.");
    }
    /* this catch is never reached because
    arithmeticexception is a subclass of exception. */
    catch(arithmeticexception e) { // error - unreachable
      system.out.println("this is never reached.");
    }
  }
}

如果你试着编译该程序，你会收到一个错误消息，该错误消息说明第二个catch语句不会到达，因为该异常已经被捕获。因为arithmeticexception 是exception的子类，第一个catch语句将处理所有的面向exception的错误，包括arithmeticexception。这意味着第二个catch语句永远不会执行。为修改程序，颠倒两个catch语句的次序。