Java异常

异常分类

Throwable类被用来表示任何可以作为异常被抛出的类。它分为两种类型：Error表示编译时和系统错误；Exception是可以被抛出的基本类型。在Java类库中，用户方法和运行时故障都有可能抛出Exception，设计程序时需要关注它。

Exception类分为RuntimeExceprion--程序错误导致的异常；其他异常--例如I/O错误。

RuntimeException情形包括：

1）错误类型转换

2）数组访问越界

3）访问null指针

其他异常情形包括：

1）试图在文件尾部后面读取数据

2）试图打开一个不存在的文件

3）试图根据给定的字符串查找Class对象，而该字符表示的类不存在。

不受检查异常：运行时异常会自动被Java虚拟机抛出，所以不必在异常说明中罗列出来，这些异常被称为不受检查异常，即从RuntimeException继承的异常。

受检查异常：而Exception下的除RuntimeException其他异常都被称为受检查异常，编译器会检查此类异常，如果不将异常捕获或抛出，将不能通过编译。

抛出异常

对于对象引用，使用对象引用调用其方法前，会对引用进行检查，可以创建一个代表错误信息的对象，并将其从当前环境中抛出，类似于：

if(t == null)
    throw new NullPointException();

在堆上会创建一个异常对象，之后当前执行路径被终止，从当前环境弹出对异常对象的引用，异常处理程序接管程序。

异常对象会传递给throw，故从效果看，可以将异常处理看做一种不同的返回机制。

String readData(Scanner in) throws EOFException
{
    //code
    while(//code)
    {
        if(in.hasNext())  //EOF encountered
        {
            if(n < len)
                throw new EOFException();
        }
        //code
    }
    return s;
}

throws是可能抛出的异常类的什么声明，写在方法参数列表后，若有多个类，则用逗号隔开。当某个方法可能会抛出某种异常时，用throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。

throw抛出的是对象，写在方法体里面。

捕获异常

使用try/catch来捕获异常，如果在try语句块中任何代码抛出了在catch语句中说明的异常类，那么程序将1）跳过try语句块的剩余代码 2）执行catch语句块的代码

try{
   //code that might generate exception
}catch(TypeOfException e){
   //Handle 
}

可以用多个catch语句来捕获多个异常

try{
   //code that might generate exception
}catch(TypeOfException xxx){
   //Handle 
}catch(Exception yyy){
    //Handle
}catch(Exception zzz){
    //Handle
}

异常对象有多个方法可以获取详细信息：getMessage()，getLocalizedMessage()，toString()，printStackTrace()等。

public class ExceptionMethods
{
    public static void main(String[] args)
    {
        try {
            throw new Exception("myException");
        }catch (Exception e){
            System.out.println("Caught Exception");
            System.out.println("getMessage" + e.getMessage() );
            System.out.println("getLocalizeMessage" + e.getLocalizedMessage());
            System.out.println("toString" + e.toString());
            System.out.println("getStacktrace");
            e.printStackTrace(System.out);
        }
    }
}

结果：

Caught Exception
getMessagemyException
getLocalizeMessagemyException
toStringjava.lang.Exception: myException
getStacktrace
java.lang.Exception: myException
    at ExceptionMethods.main(ExceptionMethods.java:6)

再次抛出异常与异常链

catch子句中可以再次抛出异常，再次抛出异常会将异常交给上一级的异常处理程序，同一个try块的后续catch子句将被忽略，该异常对象信息得到保存。

再次抛出异常的目的一般是为了改变异常类型。

try{
    access the database
}catch(SQLException e){
    throw new servletException("databaseError" + e.getMessage());
}

然而，这种方法抛出的异常，将覆盖原异常的细节，而需要保留原异常的细节并仍然抛出新异常，需要使用initCause()将异常原因描述为原异常，通过将原异常传递给新异常，即使在当前位置创建并抛出了新异常，也能通过异常链追踪到异常最初发生的位置。

try{
    access the database
}catch(SQLException e){
    throwable se = new servletException("databaseError");
    se.initCause(e);
    throw se;
}

之后可以用throwable e = se.getCause()获取原始异常.

finally子句

当代码抛出一个异常时，就会终止方法中剩余代码的处理，并退出这个方法的执行。如果方法获得了一些本地资源，并且只有这个方法自己知道，又如果这些资源在退出方法之前必须被回收，那么就会产生资源回收问题。一种解决方案是捕获并重新抛出所有的异常。但是，这种解决方案比较乏味，这是因为需要在两个地方清除所分配的资源。一个在正常的代码中；另一个在异常代码中。Java提供了finally子句解决这个问题。

不管是否有异常被捕获，finally子句中的代码都会被执行，可以在finally子句中进行资源清理。

以下例子分析程序可能执行情况：

1）代码没有异常，程序按照1,2,5,6顺序执行

2）try子句中抛出io异常，catch子句中没有再次抛出异常，程序按照1,3,4,5,6顺序执行

3）try子句中抛出io异常，catch子句中再次抛出异常，程序按照1,3,5,6,顺序执行

4）try子句抛出catch子句中没有捕获的异常，程序按照1,5,6顺序执行

InputStream in = new FileInputStream(...)
try
{
    //1
    code that might throw exception
    //2
}
catch(IOException e)
{
    //3
    show error message
    //4
}
finally
{
    //5
    in.close();
}
//6

事实上，资源清理过程中，也可能出现异常，可以使用带资源的try语句解决问题。

带资源的try语句最简形式如下，try块退出时，会自动执行res.close()

try (Resource res = . . .)
{
    work with res
}

如下示例，这个块无论正常或异常，结束后都会调用in.close()