彻底明白JAVA的异常处理-2

2. 异常规格（exception　specification）
1) 在函数定义时可以声明异常规格。如果一个函数在异常规格中声明了non-RuntimeException异常，那么当调用这个函数时，就一定要捕捉异常规格中的non-RuntimeException异常。
import java.lang.RuntimeException;
import java.lang.NullPointerException;
import java.sql.SQLException;
class TestException{
//（1）异常规格中声明将抛出RuntimeException异常
public void testRuntime() throws RuntimeException {}
//（2）异常规格中声明将抛出NullPointerException异常
public void testNullPointer() throws NullPointerException {}
//（3）异常规格中声明将抛出non-RuntimeException异常
public void testNonRuntime() throws SQLException {}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
te.testRuntime();　//（4）
te.testNullPointer();　//（5）
//te.testNonRuntime();　（6）
try{
te.testNonRuntime();
}
catch(SQLException ex){}
}
}
在上述代码中，（1）处在异常规格中声明将抛出RuntimeException；（2）在异常规格中声明将抛出NullPointerException，而NullPointerException是RuntimeException的子类，所以在调用这两个函数时，可不捕捉异常，如（4）（5）处的代码一样直接调用。但（3）处在异常规格中声明将抛出SQLException，而SQLException不是RuntimeException的子类，所以必须捕捉SQLException异常。
2) 如果要在一个函数中抛出non-RuntimeException异常，则必须要在异常规格中声明该异常。
import java.sql.SQLException;
import java.io.IOException;
class Test1{
public void f() throws SQLException{　//（2）
throw new IOException("IOException"); 　//（1）
}
}
public class ExplicitStatic{
public static void main(String[] args){
Test1 te = new Test1();
try{
te.f();
}
catch(Exception ex){
System.out.println("catch Exception in main");
}
}
}
在（1）处抛出了一个没有在异常规格中被声明的non-RuntimeException异常，在编译时会出错。
2. 取得异常中的信息的几个函数
1) String getMessage()、getLocalizedMessage 、toString
取得异常对象中的信息
import java.lang.RuntimeException;
import java.lang.NullPointerException;
Import java.sql.SQLException;
import java.io.IOException;
class TestException{
public void tSql() throws SQLException {
System.out.println("Originating the exception in tSql()");
throw new SQLException("throw in tSql");
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.tSql();
}
catch(SQLException ex){
System.out.println("catch SQLException in main");
System.out.println("ex.getMessage()：" + ex.getMessage());
System.out.println("ex.getLocalizedMessage()：" +
ex.getLocalizedMessage());
System.out.println("ex.toString()：" + ex.toString());
}
catch(Exception ex){
System.out.println("catch Exception in main");
}
}
}
运行结果：
Originating the exception in tSql()
catch SQLException in main
ex.getMessage()：throw in tSql
ex.getLocalizedMessage()：throw in tSql
ex.toString()：java.sql.SQLException: throw in tSql
2) void printStackTrace()、Throwable fillStackTrace()
printStackTrace打印出Throwable和其call　stack　trace。
FillStackTrace则在调用点设立新的stack　trace信息
import java.sql.SQLException;
class TestException{
public static void tSql() throws SQLException {
System.out.println("Originating the exception in tSql()");
throw new SQLException("throw in tSql");
}
public void f() throws SQLException{
try{
tSql();
}
catch(SQLException ex){
System.out.println("In f(), e.printStackTrace()");
ex.printStackTrace();
throw ex;　//（1）
//throw (SQLException)ex.fillInStackTrace();　（2）
}
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.f();
}
catch(SQLException ex){
System.out.println("catch in main, e.printStackTrace()");
ex.printStackTrace();
}
catch(Exception ex){
System.out.println("catch Exception in main");
}
}
}
结果为：
Originating the exception in tSql()
In f(), e.printStackTrace()
catch in main, e.printStackTrace()
java.sql.SQLException: throw in tSql
void TestException.tSql()
Test.java:5
void TestException.f()
Test.java:9
void Test.main(java.lang.String[])
Test.java:22
java.sql.SQLException: throw in tSql
void TestException.tSql()
Test.java:5
void TestException.f()
Test.java:9
void Test.main(java.lang.String[])
Test.java:22
如果把（1）处代码注释掉，并去年（2）处代码的注释，结果将变成：
Originating the exception in tSql()
In f(), e.printStackTrace()
catch in main, e.printStackTrace()
java.sql.SQLException: throw in tSql
void TestException.tSql() //（3）
Test.java:6
void TestException.f()
Test.java:10
void Test.main(java.lang.String[])
Test.java:24
java.sql.SQLException: throw in tSql
void TestException.f()　//（4）
Test.java:16
void Test.main(java.lang.String[])
Test.java:24
由于在代码（2）处设立新的stack　trace信息，所以异常会被认为是在f()中发出的，所以在main()中得到的异常原始抛出点为f()（见（3）），而在f()中为tSql()（见（6））。
3) 如果重新抛出一个不同类型的异常，也能产生fillStackTrace()函数的效果。如果把上面代码的f()函数修改成下面的样子：
public void f() throws SQLException,IOException{
try{
tSql();
}
catch(SQLException ex){
System.out.println("In f(), e.printStackTrace()");
ex.printStackTrace();
throw new IOException(); //（1）
}
}
则结果为：
Originating the exception in tSql()
In f(), e.printStackTrace()
catch Exception in main
java.sql.SQLException: throw in tSql
void TestException.tSql()
Test.java:6
void TestException.f()
Test.java:10
void Test.main(java.lang.String[])
Test.java:25
java.io.IOException
void TestException.f()
Test.java:17
void Test.main(java.lang.String[])
Test.java:25
由于在（1）处抛出了一个新的类型的异常，那么在main()中捕捉到的是新的异常，所以在main()中捕捉到的异常的原始抛出点为f()。
3. RuntimeException异常
RuntimeException及其子类所代表的异常我们在程序中不用进行捕捉，如果发生此类异常，Java会自动抛出相应的异常对象，如：
class TestException{
public static void g(int x) {
System.out.println("10/" + x + " = " + 10/x);
}
}
public class Test{
public static void main(String[] args){
TestException.g(2);
TestException.g(0);　//（1）
}
}
上面代码在编译时不会发生错误，只有在运行时（1）处会发生错误。虽然除法可能会存在错误，但我们不用进行捕捉，当发生错误时，Java会自动抛出相应异常。
二．以finally进行清理
1. 如果某段代码不管是否发生异常都要执行，那可把它改入finally块中。
import java.sql.SQLException;
class TestException{
public static void tSql() throws SQLException {
System.out.println("Originating the exception in tSql()");
throw new SQLException("throw in tSql");
}
public void f() throws SQLException{
try{
tSql();
}
catch(SQLException ex){
System.out.println("catch SQLException in f()");
throw ex;　//（1）
}
finally{
System.out.println("finally in f()");
}
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.f();
}
catch(SQLException ex){
System.out.println("catch te.f() SQLException in main");
}
catch(Exception ex){
System.out.println("catch te.f() Exception in main");
}
}
}
运行结果为：
Originating the exception in tSql()
catch SQLException in f()
finally in f()
catch te.f() SQLException in main
虽然在代码（1）处重新抛出异常，但finally块中的代码仍然会被执行。
2. finally造成的异常遗失
如果在finally中执行的代码又产生异常，那么在上一层调用中所捕捉到的异常的起始抛出点会是finally所在的函数。
import java.sql.SQLException;
class TestException{
public static void tSql1() throws SQLException {
System.out.println("Originating the exception in tSql()");
throw new SQLException("throw in tSql1");
}
public static void tSql2() throws SQLException {
System.out.println("Originating the exception in tSql()");
throw new SQLException("throw in tSql2");
}
public void f() throws SQLException{
try{
tSql1();
}
catch(SQLException ex){
System.out.println("catch SQLException in f()");
throw ex;　//（2）
}
finally{
System.out.println("finally in f()");
//tSql2();　（1）
}
}
}
public class Test{
public static void main(String[] args){
TestException te = new TestException();
try{
te.f();
}
catch(SQLException ex){
System.out.println("catch te.f() SQLException in main");
System.out.println("getMessage：" + ex.getMessage());
System.out.println("printStackTrace：");
ex.printStackTrace();
}
}
}
运行结果为：
Originating the exception in tSql()
catch SQLException in f()
finally in f()
catch te.f() SQLException in main
getMessage：throw in tSql1
printStackTrace：
java.sql.SQLException: throw in tSql1
void TestException.tSql1()
Test.java:5
void TestException.f()
Test.java:13
void Test.main(java.lang.String[])
Test.java:29
从结果可以看出，在main()中能正确打印出所捕捉到的异常的起始抛出点。但如果去掉代码（1）的注释，结果将变为：
Originating the exception in tSql()
catch SQLException in f()
finally in f()
Originating the exception in tSql()
catch te.f() SQLException in main
getMessage：throw in tSql2
printStackTrace：
java.sql.SQLException: throw in tSql2
void TestException.tSql2()
Test.java:9
void TestException.f()
Test.java:21
void Test.main(java.lang.String[])
Test.java:29
从结果可以看出，在main()中捕捉到的异常是finally中产生的异常，代码（2）中抛出的异常丢失了。