异常机制及其处理
一、异常
异常就是一个表示阻止执行正常进行的错误或者情况。比如数组下标越界访问异常：ArrayIndexOutOfBoundsException;文件不存在异常：FileNotFoundException等等。
抛出异常与异常处理的例子：除数为0异常。
package demo; import java.util.Scanner; /** * Created by luts on 2015/11/28. */ public class QuotientWithException { public static void main(String[] args){ Scanner input = new Scanner(System.in); System.out.println("输入两个数:"); int num1 = input.nextInt(); int num2 = input.nextInt(); try { if (num2 == 0) throw new ArithmeticException("除数不能为0"); System.out.println(num1 + " / " + num2 + " = " + (num1 / num2)); } catch (ArithmeticException ex){ System.out.println("除数不能为0"); } System.out.println("除法运算结束"); } }
输出：
输入两个数: 3 0 除数不能为0 除法运算结束
输入两个数: 6 3 6 / 3 = 2 除法运算结束
上述例子中，try语句是正常执行情况下的代码，如果出现异常则抛出异常。catch语句是对异常情况的处理。当程序中抛出一个异常的时候，程序的正常流程就被破坏了。throw语句用于抛出一个异常，类似于方法的调用，其调用的是catch块。catch块处理完异常后，不返回throw语句，而是执行catch块的下一条语句。
一个try-throw-catch块的模板为：
try { Code to try; Throw an exception with a throw statement or from method if necessary; more code to try; } catch (type ex){ Code to process the exception; }
1.1. 异常的类型
throwable类是所有异常类的根。所有异常类都直接或间接的继承自throwable类。可以通过Exception 或者Exception 的子类来创建自己的异常类。异常类大体分为三类：系统错误、异常和运行时异常。
· 系统错误（system error）：有java虚拟机抛出，用Error类表示。Error类描述的是内部系统错误，无法对错误进行处理。
· 异常（exception）：用Exception类表示，描述的是程序和外部环境所引起的错误，这些错误是能被程序捕获和处理的。
· 运行时异常（runtime exception）：用RuntimeException类表示，描述的是程序设计的错误。
Error类的子类例子：
| 类 | 可能引起异常的原因 |
| LinkageError | 一个类对另一个类由某种依赖性，编译前者后，后者变得不兼容 |
| VirtualMachineError | Java虚拟机中断或者没有继续运行所必需的资源可用 |
Exception类的子类例子：
| 类 | 可能引起异常的原因 |
| ClassNotFoundException | 企图使用一个不存在的类。例如试图使用Java命令来运行一个不存的类或者程序要调用三个类文件，而只能找到两个，都会发生这种异常。 |
| IOException | 同输入/输出相关的操作，例如，无效的输入、读文件时超出文件尾、打开一个不存在的文件等。 |
RuntimeException类子类的例子：
| 类 | 可能引起异常的原因 |
| ArithmetricException | 一个整数除以0. 注意：浮点运算不抛出异常 |
| NullPointerException | 企图通过一个null引用变量访问一个对象 |
| IndexOutOfBoundsException |
数组下标越界 |
| IllegalArgumentException | 传递给方法的参数非法或者不合适 |
通常情况下，免检异常都会反映出程序设计上不可恢复的逻辑错误。为了避免过多使用try-catch块，java语言不允许编写代码捕获或声明免检异常。
1.2. 异常的处理
java的异常处理模型包括：声明一个异常、抛出一个异常和捕获一个异常。
1.2.1 声明异常
声明异常：每个方法都必须声明它可能抛出的必检异常的类型。因为任何代码都可能在程序中发生系统错误或者运行时错误，所以不要求显示声明Error和RuntimeException(免检异常)。声明异常的语法：
抛出一个异常： public void myMethod() throws IOException 抛出多个异常： public void myMethod() throws IOException1,throws IOException2, ..., throws IOExceptionN
注意：如果在父类中没有声明异常，那么在子类中就不能对其进行覆盖来声明异常。
1.2.2. 抛出异常
检测一个错误的程序可以创建一个正确的异常类型的实例并抛出它，这就称为抛出异常。
例如程序调用方法时传递的参数不符合方法的签名，可以创建一个IllegalArgumentException的实例并抛出它：
IllegalArgumentException ex = new IllegalArgumentException("Wrong Arguments"); throw ex; 或者使用下列语句： throw new IllegalArgumentException("Wrong Arguments");
注意：声明异常使用关键字throws，抛出异常使用关键字throw。
1.2.3. 捕获异常
使用try-catch块来捕获异常：
try{ statements; //statemenrs that may throw exceptions } catch(Exception1 exVar1){ handle for Exception1 ; } catch(Exception2 exVar2){ handle for Exception2 ; } ... catch(ExceptionN exVarN){ handle for ExceptionN ; }
· 如果在try块中没出现异常，则跳过catch块语句。
· 如果try块中的某条语句抛出了一个异常，java就会跳过try块中剩下的语句，然后开始查找处理这个异常的代码的过程。处理这个异常的代码称为异常处理器；可以从当前方法开始，沿着调用方法的调用链，按照异常的反向传播方向找到这个处理器。从第一个到最后一个逐一检查catch块，判断是catch块中的异常实例是否是该异常对象的类型。如果是，就将该异常对象赋值给所声明的变量，然后执行catch块中的代码。如果没有发现异常处理器，java会退出这个方法，把异常传递给调用方法的方法，继续同样的过程来查找处理器。如果在调用的方法链中都找不到处理器，程序就会终止并且在控制台上打印出错信息。
需要注意的是：
· 一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
· 一个通用父类可以派生各种异常类。如果一个catch块可以捕获一个父类的异常对象，那么它就能捕获那个父类的所有子类的异常对象。
· 子类的catch块必须出现在父类的catch块之前，否则会导致编译错误。正确的例子：
try{ .... } catch (RuntimeException ex){ .... } catch (Exception ex){ .... }
· java强迫程序员必须处理必检异常。如果一个方法中声明了一个必检异常，就必须在try-catch块中调用它，或者在调用方法中声明要抛出的异常。
假设方法P1调用方法P2，P2可能会抛出一个IOException异常，那么代码编写有两种方式： 捕获异常： void p1(){ try{ p2(); } catch (IOException ex){ ...... } } 或者抛出异常： void p1() throws IOException { p2(); }
一个完整的声明、抛出、捕获异常的例子：
1 package demo; 2 3 /* 4 * 利用Circle类的setRadius方法操作如何声明、抛出和捕获异常 5 * Created by luts on 2015/11/29. 6 */ 7 public class CircleWithException { 8 9 private double radius; //圆的半径 10 11 private static int numberOfObjects = 0; //记录实例对象的个数 12 13 //构建一个半径为1的圆 14 public CircleWithException(){ 15 this(1.0); 16 } 17 18 19 //构建一个指定半径的圆 20 public CircleWithException(double newRadius){ 21 setRadius(newRadius); 22 numberOfObjects++; 23 } 24 25 //访问器 26 public double getRadius(){ 27 return radius; 28 } 29 30 //设置器，声明异常、抛出异常 31 public void setRadius(double newRadius) throws IllegalArgumentException{ 32 if (newRadius >= 0) 33 radius = newRadius; 34 else throw new IllegalArgumentException("Radius cannot be negative"); 35 } 36 37 public static int getNumberOfObjects(){ 38 return numberOfObjects; 39 } 40 41 public double findArea(){ 42 return radius * radius * Math.PI; 43 } 44 }
1 package demo; 2 3 /** 4 * Created by luts on 2015/11/29. 5 */ 6 public class TestCircleWithException { 7 public static void main(String[] args){ 8 9 //捕获异常 10 try { 11 CircleWithException c1 = new CircleWithException(5); 12 CircleWithException c2 = new CircleWithException(-5); 13 CircleWithException c3 = new CircleWithException(0); 14 } 15 catch (IllegalArgumentException ex){ 16 System.out.println(ex); 17 } 18 19 System.out.println("Number of objects created: " + CircleWithException.getNumberOfObjects()); 20 } 21 }
输出结果：
java.lang.IllegalArgumentException: Radius cannot be negative
Number of objects created: 1
1.2.4. 从异常中获取信息
异常对象包含关于异常信息的有用信息，这些信息可以通过java.lang.Throwable类中的实例方法获得：
· printStackTrace()方法在控制台上输出栈跟踪信息。
· getStackTrace()方法提高方案来访问由 printStackTrace()打印输出的栈跟踪信息。
例如上述例子，将测试类修改如下：
1 package demo; 2 3 /** 4 * Created by luts on 2015/11/29. 5 */ 6 public class TestCircleWithException { 7 public static void main(String[] args){ 8 9 //捕获异常 10 try { 11 CircleWithException c1 = new CircleWithException(5); 12 CircleWithException c2 = new CircleWithException(-5); 13 CircleWithException c3 = new CircleWithException(0); 14 } 15 catch (IllegalArgumentException ex){ 16 ex.printStackTrace(); 17 System.out.println("\n" + ex.getMessage()); 18 System.out.println("\n" + ex.toString()); 19 20 21 System.out.println("\nTrace Info Obtained from getStackTrace"); 22 StackTraceElement[] traceElements = ex.getStackTrace(); 23 for (int i = 0; i < traceElements.length; i++) { 24 System.out.print("method " + traceElements[i].getMethodName()); 25 System.out.print("(" + traceElements[i].getClassName() + ":"); 26 System.out.print( traceElements[i].getLineNumber() + ")"); 27 } 28 29 30 // System.out.println(ex); //打印一个有关异常信息的短信息ex.toStrin() 31 } 32 33 System.out.println("Number of objects created: " + CircleWithException.getNumberOfObjects()); 34 } 35 }
控制台输出：
1 java.lang.IllegalArgumentException: Radius cannot be negative <-------printStackTrac() 2 3 at demo.CircleWithException.setRadius(CircleWithException.java:34) <--------getMessage() 4 Radius cannot be negative 5 at demo.CircleWithException.<init>(CircleWithException.java:21) 6 7 at demo.TestCircleWithException.main(TestCircleWithException.java:12) <--------toString() 8 java.lang.IllegalArgumentException: Radius cannot be negative 9 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 10 11 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) <------using getStackTrace() 12 Trace Info Obtained from getStackTrace 13 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 14 method setRadius(demo.CircleWithException:34)method <init>(demo.CircleWithException:21)method main(demo.TestCircleWithException:12)method invoke0(sun.reflect.NativeMethodAccessorImpl:-2)method invoke(sun.reflect.NativeMethodAccessorImpl:62)method invoke(sun.reflect.DelegatingMethodAccessorImpl:43)method invoke(java.lang.reflect.Method:483)method main(com.intellij.rt.execution.application.AppMain:144)Number of objects created: 1 15 at java.lang.reflect.Method.invoke(Method.java:483) 16 at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
1.2.5 finally子句
finally子句：不管是否发生异常，都会执行的语句，其语法如下：
try { ..... } catch (TheException ex){ ....... } finally { fianlStatements; }
任何情况下，finally块中的代码都会执行，不管try块中是否出现异常或是否捕获异常：
· 如果try块中没有出现异常，执行finalStatements，然后执行try语句的下一条语句。
· 如果try块中有一条语句会引起异常，并被catch块捕获，然后跳过try块中的其他语句，执行catch块和finally子句。执行try语句之后的下一条语句。
· 如果try块中有一条语句引起异常，但是没有被任何catch块捕获，就会跳出try块中其他的语句，执行finally子句，并且将异常传递给该方法的调用者。
即使在到达finally块之前有一个return语句，finally语句还是会执行。
finally例子：
1 public class TestException { 2 public static void main(String args[]) { 3 int i = 0; 4 String greetings[] = { " Hello world !", " Hello World !! ", 5 " HELLO WORLD !!!" }; 6 while (i < 4) { 7 try { 8 // 特别注意循环控制变量i的设计，避免造成无限循环 9 System.out.println(greetings[i++]); 10 } catch (ArrayIndexOutOfBoundsException e) { 11 System.out.println("数组下标越界异常"); 12 } finally { 13 System.out.println("--------------------------"); 14 } 15 } 16 } 17 }
输出结果：
Hello world ! -------------------------- Hello World !! -------------------------- HELLO WORLD !!! -------------------------- 数组下标越界异常 --------------------------
小结：
· try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
· catch 块：用于处理try捕获到的异常。
· finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。
try-catch-finally 规则(异常处理语句的语法规则）：
1) 必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
2) 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
3) catch 块与相应的异常类的类型相关。
4) 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为
某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
5) 可嵌套 try-catch-finally 结构。
6) 在 try-catch-finally 结构中，可重新抛出异常。
7) 除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。
try、catch、finally语句块的执行顺序:
1） 当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；
2）当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；
3）当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句。
1.2.6 重新抛出异常
如果异常处理器没有处理某种异常，或者处理器只是希望它的调用者注意到该异常，java就允许异常处理器重新抛出异常。语法如下：
try{ ..... } catch(TheException ex){ perform operations before exits; throw ex; //重新抛出异常，以便调用者的其他处理器获得处理异常ex的机会。 }
异常链
1 package demo; 2 3 public class TestException { 4 public static void main(String args[]) { 5 try { 6 method1(); //捕获method1中的异常 7 } 8 catch (Exception ex){ 9 ex.printStackTrace(); //打印输出异常，首先显示method1 中抛出的异常，然后显示method2中抛出的异常。 10 } 11 } 12 13 public static void method1() throws Exception{ 14 try{ 15 method2(); //捕获method2中的异常 16 } 17 catch(Exception ex){ 18 throw new Exception("New info from method1", ex); //抛出一个新的异常 19 } 20 } 21 22 public static void method2() throws Exception{ 23 throw new Exception("New info from metho2"); //抛出一个异常，该异常被method1 的catch块捕获 24 } 25 }
输出：
1 java.lang.Exception: New info from method1 2 at demo.TestException.method1(TestException.java:18) 3 at demo.TestException.main(TestException.java:6) 4 Caused by: java.lang.Exception: New info from metho2 5 at demo.TestException.method2(TestException.java:23) 6 at demo.TestException.method1(TestException.java:15) 7 ... 1 more
关于异常处理知识的深入知识，可以参阅：[深入理解java异常处理机制]
