CSDN博客

img Nepalon

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

发表于2003/11/23 19:17:00  1417人阅读

分类: 学习笔记

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,而NullPointerExceptionRuntimeException的子类,所以在调用这两个函数时,可不捕捉异常,如(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

getMessagethrow 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

getMessagethrow 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)中抛出的异常丢失了。

0 0

相关博文

我的热门文章

img
取 消
img