定义
在程序中，如果不处理异常，正常运行的程序会完全停止运行。异常是程序正常运行中，可以预料的意外情况，可能并且应该被捕获，进行相应处理。
Exception：Exception又分为可检查（checked）异常和不检查（unchecked）异常。
- 可检查异常（非运行时异常），是RuntimeException以外的异常，类型上都属于Exception类和其子类，如IOException、SQLException等以及用户自定义的Exception异常。对于这种异常，java编译器强制要求我们必须对出现的这些异常进行处理，否则程序就不能编译通过。
- 不检查异常（运行时异常），其异常都是RuntimeException类及其子类，如 NullPointerException、ArrayIndexOutOfBoundsException之类，这些异常可以选择在程序里捕获处理，也可以不处理，一般是由程序逻辑错误引起的，从逻辑的角度去避免这种异常的发生，如果不处理该异常，程序会把异常一直往上层抛，一直到最上层，导致线程退出或者程序退出。
Java 异常的处理机制
Java的异常处理本质上是抛出异常和捕获异常。
- 抛出：在当前环境下无法获得必要的信息来解决问题，从当前环境中跳出，并把问题提交给上一级环境，这就是抛出异常
捕获异常：使用try-catch块，在抛出异常的时候，将其转为寻找合适的异常处理器，来处理它，或者忽略异常，让程序继续执行。
异常处理的基础语法
Java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。
try-catch
try{ //监控区域 }catch(Exception e){ //the code of handling exception1 }catch(Exception e){ //the code of handling exception2 }
try-catch所描述的即是监控区域，关键词try后的一对大括号将一块可能发生异常的代码包起来，即为监控区域。Java方法在运行过程中发生了异常，则创建异常对象。将异常抛出监控区域之外，由Java运行时系统负责寻找匹配的catch子句来捕获异常。若有一个catch语句匹配到了，则执行该catch块中的异常处理代码，就不再尝试匹配别的catch块了。
使用多重的catch语句：很多情况下，由单个的代码段可能引起多个异常。处理这种情况，我们需要定义两个或者更多的catch子句，每个子句捕获一种类型的异常，当异常被引发时，每个catch子句被依次检查，第一个匹配异常类型的子句执行，当一个catch子句执行以后，其他的子句将被旁路，异常类型从大到小，从上到下依次处理。
反例：Exception异常应该是放在ArrayIndexOutOfBoundsException后面，下面的写法会让Exception后面的异常处理被屏蔽掉。
反例： try{ //code that might generate exceptions }catch(Exception e){ //the code of handling exception1 }catch(ArrayIndexOutOfBoundsException e){ //the code of handling exception2 } 正确处理： try{ //code that might generate exceptions }catch(ArrayIndexOutOfBoundsException e){ //the code of handling exception1 }catch(Exception e){ //the code of handling exception2 }
嵌套try语句：try语句可以被嵌套。也就是说，一个try语句可以在另一个try块的内部。每次进入try语句，异常的前后关系都会被推入堆栈。如果一个内部的try语句不含特殊异常的catch处理程序，堆栈将弹出，下一个try语句的catch处理程序将检查是否与之匹配。这个过程将继续直到一个catch语句被匹配成功，或者是直到所有的嵌套try语句被检查完毕。如果没有catch语句匹配，Java运行时系统将处理这个异常。
try{ try{ //code that might generate exceptions }catch(IOException e){ //the code of handling exception1 } }catch(Exception e){ //the code of handling exception1 }
throw
throw 用于抛出明确的异常。程序执行完throw语句之后立即停止；throw后面的任何语句不被执行，最邻近的try块用来检查它是否含有一个与异常类型匹配的catch语句。如果发现了匹配的块，控制转向该语句；如果没有发现，次包围的try块来检查，以此类推。如果没有发现匹配的catch块，默认异常处理程序中断程序的执行并且打印堆栈轨迹。
throw new NullPointerException("demo");
throws
如果一个方法会出现异常但却不处理它，那么这个方法必须明确这个异常，以使方法的调用者调用时不发生异常。要做到这点，我们可以在方法声明中包含一个throws子句。
public void info() throws Exception
{
//body of method
throw new IllegalAccessException(); }
info()方法里面，明确地会出现异常IllegalAccessException，但是却不想捕获处理而是抛出去，那么它必须在方法上明确这个存在着异常。
Throws抛出异常的规则
- 如果是不受检查异常（
unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。 - 如果一个方法可能出现受检查异常（checked exception），要么用
try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误 - 仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
- 调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
finally
无论是否发生异常，我们都有需要执行的代码，这就是 final关键字的所在。例如我们在读取文件文件的时候，如果是否发生了异常，都希望最后能关闭这个文件的流。finally子句是可选项，可以有也可以无，但是每个try语句至少需要一个catch或者finally子句。
public int getPlayerScore(String playerFile) { Scanner contents; try { contents = new Scanner(new File(playerFile)); return Integer.parseInt(contents.nextLine()); } catch (FileNotFoundException noFile ) { logger.warn("File not found, resetting score."); return 0; } finally { try { if (contents != null) { contents.close(); } } catch (IOException io) { logger.error("Couldn't close the reader!", io); } } }
try-with-resources
JDK1.7之后有了try-with-resource处理机制。首先被自动关闭的资源需要实现Closeable或者AutoCloseable接口，因为只有实现了这两个接口才可以自动调用close()方法去自动关闭资源。
接口实现AutoCloseable接口，重写close方法：
public class Connection implements AutoCloseable { public void sendData() { System.out.println("正在发送数据"); } @Override public void close() throws Exception { System.out.println("正在关闭连接"); } }
调用：
public class TryWithResource { public static void main(String[] args) { try (Connection conn = new Connection()) { conn.sendData(); } catch (Exception e) { e.printStackTrace(); } } }
运行结果：
正在发送数据
正在关闭连接
原理
反编译刚才例子的class文件：
public class TryWithResource { public TryWithResource() { } public static void main(String[] args) { try { Connection e = new Connection(); Throwable var2 = null; try { e.sendData(); } catch (Throwable var12) { var2 = var12; throw var12; } finally { if(e != null) { if(var2 != null) { try { e.close(); } catch (Throwable var11) { var2.addSuppressed(var11); } } else { e.close(); } } } } catch (Exception var14) { var14.printStackTrace(); } } }
编译器自动帮我们生成了finally块，并且在里面调用了资源的close方法，所以例子中的close方法会在运行的时候被执行。不过在catch(){}代码块中有一个addSuppressed()方法，即异常抑制方法。如果业务处理和关闭连接都出现了异常，业务处理的异常会抑制关闭连接的异常，只抛出处理中的异常，仍然可以通过getSuppressed()方法获得关闭连接的异常。
稍微修改一下刚才的例子：我们将刚才的代码改回远古时代手动关闭异常的方式，并且在sendData和close方法中抛出异常：
public class Connection implements AutoCloseable { public void sendData() throws Exception { throw new Exception("send data"); } @Override public void close() throws Exception { throw new MyException("close"); } }
public class TryWithResource { public static void main(String[] args) { try { test(); } catch (Exception e) { e.printStackTrace(); } } private static void test() throws Exception { Connection conn = null; try { conn = new Connection(); conn.sendData(); } finally { if (conn != null) { conn.close(); } } } }
运行结果：由于我们一次只能抛出一个异常，所以在最上层看到的是最后一个抛出的异常——也就是close方法抛出的MyException，而sendData抛出的Exception被忽略了。这就是所谓的异常屏蔽。
basic.exception.MyException: close at basic.exception.Connection.close(Connection.java:10) at basic.exception.TryWithResource.test(TryWithResource.java:82) at basic.exception.TryWithResource.main(TryWithResource.java:7) ......
用try-with-resource的方式再次运行
public class TryWithResource { public static void main(String[] args) { try (Connection conn = new Connection()) { conn.sendData(); } catch (Exception e) { e.printStackTrace(); } } }
运行结果：异常信息中多了一个Suppressed的提示，告诉我们这个异常其实由两个异常组成，MyException是被Suppressed的异常。
java.lang.Exception: send data at basic.exception.Connection.sendData(Connection.java:5) at basic.exception.TryWithResource.main(TryWithResource.java:14) ...... Suppressed: basic.exception.MyException: close at basic.exception.Connection.close(Connection.java:10) at basic.exception.TryWithResource.main(TryWithResource.java:15) ... 5 more
在使用try-with-resource的过程中，一定需要了解资源的close方法内部的实现逻辑。否则还是可能会导致资源泄露。
举个例子，在Java BIO中采用了大量的装饰器模式。当调用装饰器的close方法时，本质上是调用了装饰器内部包裹的流的close方法。
public class TryWithResource { public static void main(String[] args) { try (FileInputStream fin = new FileInputStream(new File("input.txt")); GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(new File("out.txt")))) { byte[] buffer = new byte[4096]; int read; while ((read = fin.read(buffer)) != -1) { out.write(buffer, 0, read); } } catch (IOException e) { e.printStackTrace(); } } }
在上述代码中，我们从FileInputStream中读取字节，并且写入到GZIPOutputStream中。GZIPOutputStream实际上是FileOutputStream的装饰器。由于try-with-resource的特性，实际编译之后的代码会在后面带上finally代码块，并且在里面调用fin.close()方法和out.close()方法。我们再来看GZIPOutputStream类的close方法：
public void close() throws IOException { if (!closed) { finish(); if (usesDefaultDeflater) def.end(); out.close(); closed = true; } }
我们可以看到，out变量实际上代表的是被装饰的FileOutputStream类。在调用out变量的close方法之前，GZIPOutputStream还做了finish操作，该操作还会继续往FileOutputStream中写压缩信息，此时如果出现异常，则会out.close()方法被略过，然而这个才是最底层的资源关闭方法。正确的做法是应该在try-with-resource中单独声明最底层的资源，保证对应的close方法一定能够被调用。在刚才的例子中，我们需要单独声明每个FileInputStream以及FileOutputStream：
public class TryWithResource { public static void main(String[] args) { try (FileInputStream fin = new FileInputStream(new File("input.txt")); FileOutputStream fout = new FileOutputStream(new File("out.txt")); GZIPOutputStream out = new GZIPOutputStream(fout)) { byte[] buffer = new byte[4096]; int read; while ((read = fin.read(buffer)) != -1) { out.write(buffer, 0, read); } } catch (IOException e) { e.printStackTrace(); } } }
由于编译器会自动生成fout.close()的代码，这样肯定能够保证真正的流被关闭。
参考：