概念

在早期没有专门的异常处理机制的时候,比如C语言,会通过一些约定俗成的东西来处理异常. 比如让程序返回某个特殊的值或者设置某个标记. 然后对返回值进行检查以判断程序是否出错. 还记得以前C语言的时候,return 0和return -1对异常处理的实现可以追溯到BASIC中的on error goto语句. C++的异常处理机制基于Ada,而Java的异常处理是建立在C++之上的.

叫异常的意思是,问题出现了,但是可能还不知道该如何处理,但是确定这个问题不能置之不理,这个时候要停下来看看别人或者别的地方是不是能够处理这个问题. 换句话说就是:当前环境中没有足够的信息来解决遇到的问题的时候,就应该把问题提交给一个更高级别的环境中去解决 这也是异常处理的基本思路.
使用异常处理的好处是能够降低处理错误代码的复杂度. 它可以把正常的代码和出了问题需要处理的代码相分离.

基本异常情形

异常情形就是组织当前方法或作用域继续执行的问题. 不是出了所有问题都叫异常,如果当前环境下能够得到足够的信息,总能handle这个要处理的问题的时候,这种情形应该被视作普通情形不是异常. 只有在当前环境中得不到足够的信息来解决问题的时候,我们所能做的就是从当前环境跳出,并且把问题交给上一级环境. 异常处理所需要关注的点.

异常抛出后会发生的事情

• 使用new在堆上创建一个异常对象.
• 当前执行路径被终止,并且从当前环境中弹出对异常对象的引用
• 异常处理机制接管程序,并循环早一个合适的地方继续执行程序(这个合适的地方就是异常处理程序)
• 异常处理程序从错误状态中恢复,程序要么换一种方式运行,要么继续运行下去

比如,

1.if(t==null)
2.    throw new NullPointerException

比如这一段代码,异常抛出以后,当前环境就不需要再为这个问题所操心了, 它会在别的地方得到处理.

异常参数
首先要知道,异常在java中也是一个new在堆上的对象. 也涉及存储空间的分配和构造器调用. 其中最常用的两个构造器分别是:

• 无参构造器
• 带String message的有参构造器

异常抛出的时候使用throw关键字,在new了异常对象之后,其引用会传递给throw. 看上去就像正常方法的return一样. 但是异常返回的地点和普通方法调用返回的地方不一样. 异常在一个恰当的异常处理程序中得到解决. 它的位置可能离异常抛出的地方很远,也可能会跨越方法调用栈的很多层次.

Throwable是所有异常的跟类,throw关键字可以用于抛出任何Throwable对象.

异常的捕获

要知道异常怎么捕获就得先了解”监控区域”的概念.
try块
简单来说,try块就是一个自定义的监控区域. 也就是在这个块里try可能产生异常的代码. 如果有问题就throw出去.

catch
抛出的异常必须得到处理,处理的底单就是”异常处理程序”.它会紧跟在try块之后,以关键字catche表示.

1.try {  
2.  // Code that might generate exceptions  
3.} catch(Type1 id1)|{  
4.  // Handle exceptions of Type1  
5.} catch(Type2 id2) {  
6.  // Handle exceptions of Type2  
7.} catch(Type3 id3) {  
8.  // Handle exceptions of Type3  
9.}  
10.
11.// etc... 

catch块看上去就像仅接收一个特殊入参的方法. 这玩意儿跟方法的使用很相似. 异常处理机制搜参数和异常类型相匹配的第一个处理程序,然后进入catch子句执行. 需要注意的是,catch块有且仅有一个被执行.

终止与恢复
异常处理有两种模型,一种是终止模型. 这种模型下,假设异常错误非常关键,以至于程序无法回到异常发生的地方继续执行. 一旦异常被抛出,表明错误已经无法挽回,不能回头继续执行.
还有一种叫做恢复模型,意思是异常处理的工作是修正错误,然后尝试重新调用出问题的方法,并且认为第二次能成功.

java采用的是终止模型. 但是如果想让java实现恢复模型,可以将try块放在while循环里,这就会不断的进入try块直到得到满意的结果.

自定义异常

java提供的异常类型已经很丰富了. 但是如果有些时候需要自己去定义的话,也是可以的. 定义自己的异常类必须从已有的异常类型继承. 最简单的办法就是让编译器来产生构造器.

1.class SimpleException extends Exception{
2.
3.}
4.
5.public class InheritingExceptions{
6.    public void f() throws SimpleException{
7.        System.err.println("Throw SimpleException from f()");
8.        throw new SimpleException();
9.    }
10.    public static void main(String[] args) {
11.        InheritingExceptions sed = new InheritingExceptions();
12.        try {
13.            sed.f();
14.        } catch (SimpleException e) {
15.            // TODO: handle exception
16.            System.out.println("catch it");
17.        }
18.    }
19.}

直接调用基类的默认构造器其实就可以了. 这里有必要提到的一点是,异常信息打印的位置. 打印到System.err的标准错误流是比较合适的. 因为标准输出流可能会被重定向. 而且把该送的东西送到它该去的地方,总是没错的.

1.class MyException extends Exception{
2.    public MyException(){super();}
3.    public MyException(String msg){
4.        super(msg);
5.    }
6.}
7.
8.public class FullConstructors {
9.    public static void f() throws MyException{
10.        System.out.println("throwing MyException from f()");
11.        throw new MyException();
12.    } 
13.    public static void g()throws MyException{
14.        System.out.println("Throwing MyException from g()");
15.        throw new MyException("Originated in g()");
16.    } 
17.    public static void main(String[] args) {
18.        try {
19.            f();
20.        } catch (MyException e) {
21.            // TODO: handle exception
22.            e.printStackTrace(System.out);
23.        }
24.        try {
25.            g();
26.        } catch (MyException e) {
27.            // TODO: handle exception
28.            e.printStackTrace(System.out);
29.        }
30.    }
31.}/*
32.throwing MyException from f()
33.ch12_Exception.MyException
34.    at ch12_Exception.FullConstructors.f(FullConstructors.java:13)
35.    at ch12_Exception.FullConstructors.main(FullConstructors.java:21)
36.Throwing MyException from g()
37.ch12_Exception.MyException: Originated in g()
38.    at ch12_Exception.FullConstructors.g(FullConstructors.java:17)
39.    at ch12_Exception.FullConstructors.main(FullConstructors.java:27)
40.
41.*/

这是带参数构造器和不带参数构造器打印内容的区别.

日志记录

1.import java.io.PrintWriter;
2.import java.io.StringWriter;
3.import java.util.logging.*;
4.
5.class LoggingExceptions extends Exception{
6.    private static Logger logger = Logger.getLogger("Logging Execptions");
7.    public LoggingExceptions(){
8.        StringWriter trace = new StringWriter();
9.        printStackTrace(new PrintWriter(trace));
10.        logger.severe(trace.toString());
11.    }
12.}
13.
14.public class LoggingException {
15.    public static void main(String[] args) {
16.        try {
17.            throw new LoggingExceptions();
18.        } catch (LoggingExceptions e) {
19.            // TODO: handle exception
20.            System.err.println("Caught "+e);
21.        }
22.
23.        try {
24.            throw new LoggingExceptions();
25.        } catch (LoggingExceptions e) {
26.            // TODO: handle exception
27.            System.err.println("Caught "+e);
28.        }
29.    }
30.}

向自定义异常类中定义其他成员
首先异常类也是一个类,它可以定义自己的成员方法和成员变量.

1.class MyException2 extends Exception{
2.    private int x;
3.    public MyException2(){
4.        super();
5.    }
6.    public MyException2(String msg){
7.        super(msg);
8.    }
9.    public MyException2(String msg,int x){
10.        super(msg);
11.        this.x = x;
12.    }
13.    public int val(){
14.        return x;
15.    }
16.    public String getMessage(){
17.        return "Detail Message: "+x+" "+super.getMessage();
18.    }
19.}
20.public class ExtralFeature {
21.    public static void f() throws MyException2{
22.        System.out.println("Throwing MyExcetion2 from f()");
23.        throw new MyException2();
24.    } 
25.    public static void g() throws MyException2{
26.        System.out.println("Throwing MyExcetion2 from g()");
27.        throw new MyException2("Originated in g()");
28.    } 
29.    public static void h() throws MyException2{
30.        System.out.println("Throwing MyExcetion2 from h()");
31.        throw new MyException2("Originated in h()",47);
32.    } 
33.
34.    public static void main(String[] args) {
35.        for(int i=0;i<5;i++){
36.            try {
37.                f();
38.            } catch (MyException2 e) {
39.                // TODO: handle exception
40.                e.printStackTrace();
41.            }
42.            try {
43.                g();
44.            } catch (MyException2 e) {
45.                // TODO: handle exception
46.                e.printStackTrace();
47.            }
48.
49.            try {
50.                h();
51.            } catch (MyException2 e) {
52.                // TODO: handle exception
53.                e.printStackTrace();
54.                System.out.println("e.val="+e.val());
55.            }
56.            System.out.println("========================================");
57.        }
58.    }
59.}

遇到一个问题, 预期跟实际输出不一样. 有点蒙了,刚发了个帖子问,还在等答案…

异常说明

java鼓励大家把方法肯能会抛出的异常告诉使用此方法的程序员. 这种做法可以让调用者知道该方法可能出现的异常.如果可以看到源码,那么在源码中可以知道方法可能会抛出的异常. 如果看不到源码岂不是蒙圈了. 所以java提供了一个throws关键字,跟在方法名称定义的后面,表示该方法内部可能会抛出的异常.
比如public void f() throws Exception1,Exception2,Exception3...如果没有throws的话,表示出了从RuntimeException继承的异常,它不会抛出任何其他异常.
需要注意的是,throws抛出的异常和代码中的说明必须一致. 也就是说,要么处理这个异常,要么在函数声明的时候抛出去. 但是可以在声明方法的时候throws异常,但实际代码上不throw. 也就是预先定义这个异常,以后不需要再修改这里的代码了. 这个在定义抽象类和接口的时候比较常用.

捕获所有异常

可以通过捕获异常类型的基类性Exception来用一个catch块捕获所有的异常. 但是用的时候,最好是将其放在所有catch块的最后. 这里就涉及到了java捕获异常的顺序了. java会按照代码的顺序,进入第一个匹配到的catch块. 正常来说,我们希望异常捕获的越精确越好. 所以在写多个catch块的时候,一般按照异常的”由小到大”的顺序来写.

Exception
Exception类是和编程相关的所有异常类的基类. 通过这类可以调用从Throwable类中调用的一些方法:

• String getMessage() 返回一个简短描述信息
• String getLocalizedMessage()
• String toString()
• void printStackTrace() 显示异常抛出地点的方法调用序列.

1.public class ExceptionMethod {
2.    public static void main(String[] args) {
3.        try {
4.            throw new Exception("My exception");
5.        } catch (Exception e) {
6.            System.out.println("Caught Exception");
7.            System.out.println("getMessage(): "+e.getMessage());
8.            System.out.println("getLocalMessage():"+e.getLocalizedMessage());
9.            System.out.println("toString():"+e.toString());
10.            e.printStackTrace();
11.        }
12.    }
13.}/*output:
14.Caught Exception
15.getMessage(): My exception
16.getLocalMessage():My exception
17.toString():java.lang.Exception: My exception
18.java.lang.Exception: My exception
19.    at ch12_Exception.ExceptionMethod.main(ExceptionMethod.java:6)
20.*/

异常的信息就是那么多,而每个方法是指选择不同的部分来显示. 其实每个方法都是前一个方法的超集.

栈轨迹

printStackTrace()方法所提供的信息可以通过getStackTrace()方法直接访问.这个方法返回一个由栈轨迹中的元素所构成的数组. 其中每个元素表示栈中的一帧. 0表示栈顶元素,也就是最后的一个方法调用.也是Throwable对象被创建和抛出的地方. 最后一个元素是第一个方法调用.

1.public class WhoCalled {
2.    static void f(){
3.        try {
4.            throw new Exception();
5.        } catch (Exception e) {
6.            // TODO: handle exception
7.            for(StackTraceElement ste:e.getStackTrace()){
8.                System.out.println(ste.getMethodName());
9.            }
10.        }
11.    }
12.    static void g(){
13.        f();
14.    }
15.    static void h(){
16.        g();
17.    }
18.    public static void main(String[] args) {
19.        f();
20.        System.out.println("--------------------");
21.        g();
22.        System.out.println("--------------------");
23.        h();
24.        System.out.println("--------------------");
25.    }
26.}/*
27.f
28.main
29.--------------------
30.f
31.g
32.main
33.--------------------
34.f
35.g
36.h
37.main
38.--------------------
39.*/

重新抛出异常

有时候我们需要在捕获异常之后重新抛出,尤其是使用Exception捕获所有异常的时候,既然已经拿到了异常的引用,可以直接再把它抛出去.重新抛出异常给上一级环境中的异常处理程序,同一个try块的后续catch子句将被忽略. 所以上一级环境中的异常处理程序可以对这个异常对象中拿到所有信息. 如果只是把当前对象重新抛出,那么上一级的异常处理程序得到将会是原来异常抛出点的栈调用信息. 而非新抛出点的信息. 果想要更新,可以调用fillInStackTrace(). 这将返回一个Throwable对象,它是通过当前调用栈信息填入原来那个异常对象而建立的.

1.public class Rethrowing {
2.    public static void f() throws Exception{
3.        System.out.println("origination exception in f()");
4.        throw new Exception("throw from f()");
5.    } 
6.    public static void g() throws Exception{
7.        try{
8.            f();
9.        }catch (Exception e) {
10.            // TODO: handle exception
11.            System.out.println("Inside g(),e.printStackTrace()");
12.            e.printStackTrace(System.out);
13.            throw e;
14.        }
15.    }
16.    public static void h() throws Exception{
17.        try {
18.            f();
19.        } catch (Exception e) {
20.            // TODO: handle exception
21.            System.out.println("Inside h(),e.printStackTrace()");
22.            e.printStackTrace(System.out);
23.            throw (Exception)e.fillInStackTrace();
24.        }
25.    }
26.    public static void main(String[] args) {
27.        try {
28.            g();
29.        } catch (Exception e) {
30.            // TODO: handle exception
31.            System.out.println("Main:printStackTrace()");
32.            e.printStackTrace(System.out);
33.        }
34.
35.        try {
36.            h();
37.        } catch (Exception e) {
38.            // TODO: handle exception
39.            System.out.println("Main:printStackTrace()");
40.            e.printStackTrace(System.out);
41.        }
42.    }
43.}/*output:
44.origination exception in f()
45.Inside g(),e.printStackTrace()
46.java.lang.Exception: throw from f()
47.    at ch12_Exception.Rethrowing.f(Rethrowing.java:6)
48.    at ch12_Exception.Rethrowing.g(Rethrowing.java:10)
49.    at ch12_Exception.Rethrowing.main(Rethrowing.java:30)
50.Main:printStackTrace()
51.java.lang.Exception: throw from f()
52.    at ch12_Exception.Rethrowing.f(Rethrowing.java:6)
53.    at ch12_Exception.Rethrowing.g(Rethrowing.java:10)
54.    at ch12_Exception.Rethrowing.main(Rethrowing.java:30)
55.
56.
57.
58.origination exception in f()
59.Inside h(),e.printStackTrace()
60.java.lang.Exception: throw from f()
61.    at ch12_Exception.Rethrowing.f(Rethrowing.java:6)
62.    at ch12_Exception.Rethrowing.h(Rethrowing.java:20)
63.    at ch12_Exception.Rethrowing.main(Rethrowing.java:38)
64.
65.Main:printStackTrace()
66.java.lang.Exception: throw from f()
67.    at ch12_Exception.Rethrowing.h(Rethrowing.java:25)
68.    at ch12_Exception.Rethrowing.main(Rethrowing.java:38)
69.*/

看67,68行,这里是执行了fillInStackTrace()之后的,异常抛出的地点.

当然,可以在catch块中抛出另外一个异常.

1.class OneException extends Exception{
2.    public OneException(String s){
3.        super(s);
4.    }
5.}
6.class TwoException extends Exception{
7.    public TwoException(String s){
8.        super(s);
9.    }
10.}
11.
12.public class ReThrowNew {
13.    public static void f() throws OneException{
14.        System.out.println("originating the exception in f()");
15.        throw new OneException("throw from f()");
16.    } 
17.    public static void main(String[] args) {
18.        try {
19.            try {
20.                f();
21.            } catch (OneException e) {
22.                // TODO: handle exception
23.                System.out.println("Caught in inner try,e.printStackTrace()");
24.                e.printStackTrace(System.out);
25.                throw new TwoException("from inner try");
26.            }
27.        } catch (TwoException e) {
28.            // TODO: handle exception
29.            System.out.println("Caught in outer try,e.printStackTrace()");
30.            e.printStackTrace(System.out);
31.
32.        }
33.    }
34.}/*output:
35.originating the exception in f()
36.Caught in inner try,e.printStackTrace()
37.ch12_Exception.OneException: throw from f()
38.    at ch12_Exception.ReThrowNew.f(ReThrowNew.java:17)
39.    at ch12_Exception.ReThrowNew.main(ReThrowNew.java:22)
40.Caught in outer try,e.printStackTrace()
41.ch12_Exception.TwoException: from inner try
42.    at ch12_Exception.ReThrowNew.main(ReThrowNew.java:27)
43.*/

后面这个异常,只有main方法才知道,f()方法对其一无所知.

Java标准异常

Throwable是java中任何可以作为异常被抛出的类.(注意,不是Exception,不是Exception,不是Exception) Throwable
对象可以分为两种类型:Error用来表示编译时和系统错误. Exception是可被抛出的基本类型. 在java类库,用户方法,以及运行时问题,都可能会抛出Exception. 这也是java程序员最关心的问题.

java的异常类型其实都很简单,主要是靠名字. java异常的概念,是使用名称表示发生的问题. 也就是通过名字就大概可以知道发生了什么问题. 所以在自定义异常的时候也要注意,不要起Exception1这种恶心的名字.

注意一个特例,RuntimeException. 运行时异常很多,比如空指针错,这些错误都继承自RuntimeException. 会被JVM自动抛出. 他们也被称为是不受检查的异常. 如果没有对RuntimeException异常进行捕获,那么,它就会穿越所有方法,直到main方法然后抛出,然后会调用printStackStrace(). 对于这种异常,不需要说明,其输出报告就直接到了System.err.

使用finally

一般抛出异常之后,方法就会被终止,在异常之后的代码就没有办法执行了. 但是有一些代码,比如关闭数据库连接,关闭流等,如果在执行之前抛出了异常,那就悲剧了. 所以一些出了内存回收之外的清理动作,是无论异常是否发生都要执行的. 怎么办呢,java提供了finally子句.

关于finally子句,只需要记住一句话,finally子句总会被执行. 无论是否有异常都会执行. 那么如果程序在try块中return了呢?

1.public class FianllyTest {
2.    public static int f(int val){
3.        try {
4.            System.out.println("111");
5.            if(val==1) return 1;
6.            else if(val==2) return 2;
7.            else return 23333;
8.        } finally {
9.            // TODO: handle finally clause
10.            System.out.println("I am in finally block");
11.        }
12.    }
13.    public static void main(String[] args) {
14.        System.out.println(f(10));
15.        System.out.println(f(1));
16.        System.out.println(f(2));
17.
18.    }
19.}/*output:
20.111
21.I am in finally block
22.23333
23.111
24.I am in finally block
25.1
26.111
27.I am in finally block
28.2
29.*/

看这个例子就明白了,finally子句总会被执行,即使try块中已经return了,它还是会执行的.

异常丢失

1.
2.class VeryImportantException extends Exception{
3.    public String toString(){
4.        return "A very important exception";
5.    }
6.}
7.
8.class HoHumException extends Exception{
9.    public String toString(){
10.        return "a trival exception";
11.    }
12.}
13.public class LostMessage {
14.    void f() throws VeryImportantException{
15.        throw new VeryImportantException();
16.    }
17.    void dispose()throws HoHumException{
18.        throw new HoHumException();
19.    } 
20.    public static void main(String[] args) {
21.        try{
22.            LostMessage lm = new LostMessage();
23.            try{
24.                lm.f();
25.            }finally {
26.                lm.dispose();
27.            }
28.        }catch (Exception e) {
29.                // TODO: handle exception
30.                System.out.println(e);
31.            }
32.
33.    }
34.}

看这么一个例子,VeryImportantException不见了. 只捕获到了HoHumException. 这种情况是不应该出现的,按照剧本来说,这种情况是不应该出现的.按照C++的思路,前一个异常还没有处理就抛出下一个异常,这是不应该的. 但是java并没有对其做很好的检查. 在使用try-finall结构的时候很有可能会出现这种情况. 所以暂时,或许我们只能靠良好的编程习惯来解决它. 尽量使用try-catch-finally结构.

1.try{
2.                lm.f();
3.            }catch (Exception e) {
4.                // TODO: handle exception
5.                System.out.println(e);
6.            }
7.            finally {
8.                lm.dispose();
9.            }

异常的限制

所谓异常限制就是,当覆盖方法的时候,只能抛出基类方法的异常说明中列出来的那些异常.这个限制很有用,当基类的代码应用到其派生类的时候,一样能够工作.

1.//: exceptions/StormyInning.java 
2.//Overridden methods may throw only the exceptions 
3.//specified in their base-class versions, or exceptions 
4.//derived from the base-class exceptions. 
5.
6.class BaseballException extends Exception {
7.}
8.
9.class Foul extends BaseballException {
10.}
11.
12.class Strike extends BaseballException {
13.}
14.
15.abstract class Inning {
16.    public Inning() throws BaseballException {
17.    }
18.
19.    public void event() throws BaseballException {
20.        // Doesn’t actually have to throw anything
21.    }
22.
23.    public abstract void atBat() throws Strike, Foul;
24.
25.    public void walk() {
26.    } // Throws no checked exceptions
27.}
28.
29.class StormException extends Exception {
30.}
31.
32.class RainedOut extends StormException {
33.}
34.
35.class PopFoul extends Foul {
36.}
37.
38.interface Storm {
39.    public void event() throws RainedOut;
40.
41.    public void rainHard() throws RainedOut;
42.}
43.
44.public class StormyInning extends Inning implements Storm {
45.    // OK to add new exceptions for constructors, but you
46.    // must deal with the base constructor exceptions:
47.    public StormyInning() throws RainedOut, BaseballException {
48.    }
49.
50.    public StormyInning(String s) throws Foul, BaseballException {
51.    }
52.
53.    // Regular methods must conform to base class:
54.    // ! void walk() throws PopFoul {} //Compile error
55.    // Interface CANNOT add exceptions to existing
56.    // methods from the base class:
57.    // ! public void event() throws RainedOut {}
58.    // If the method doesn’t already exist in the
59.    // base class, the exception is OK:
60.    public void rainHard() throws RainedOut {
61.    }
62.
63.    // You can choose to not throw any exceptions,
64.    // even if the base version does:
65.    public void event() {
66.    }
67.
68.    // Overridden methods can throw inherited exceptions:
69.    public void atBat() throws PopFoul {
70.    }
71.
72.    public static void main(String[] args) {
73.        try {
74.            StormyInning si = new StormyInning();
75.            si.atBat();
76.        } catch (PopFoul e) {
77.            System.out.println("Pop foul");
78.        } catch (RainedOut e) {
79.            System.out.println("Rained out");
80.        } catch (BaseballException e) {
81.            System.out.println("Generic baseball exception");
82.        }
83.        // Strike not thrown in derived version.
84.        try {
85.            // What happens if you upcast?
86.            Inning i = new StormyInning();
87.            i.atBat();
88.            // You must catch the exceptions from the
89.            // base-class version of the method:
90.        } catch (Strike e) {
91.            System.out.println("Strike");
92.        } catch (Foul e) {
93.            System.out.println("Foul");
94.        } catch (RainedOut e) {
95.            System.out.println("Rained out");
96.        } catch (BaseballException e) {
97.            System.out.println("Generic baseball exception");
98.        }
99.    }
100.} /// :~
101.

看埃大爷的书学了不少单词…

• 在Inning类中,构造器和event()方法都声明要抛出异常,实际上却没有抛出. 这种方式可以强制让用户去捕获可能在重写后增加的异常.对于抽象方法,同样适用.
• Storm接口中,包含了一个Inning定义的event()方法和不再Inning中定义的rainHard方法. 这两个方法都抛出新的异常,RainedOut. 如果扩展类中继承了Inning类又实现了Storm接口,那么在扩展类中就不能改变基类的throws的异常列表. 所以在扩展类中,可以看到event()方法没有抛出异常.
• 如果接口中定义的方法没有和基类中的重名,比如rainHard(),那么此方法,抛出什么样的异常都无所谓.
• 异常限制对构造器不起作用. 但是,因为基类构造器在扩展类中必须被调用. 所以派生类的构造器必须抛出包含基类构造器所抛出的异常
• walk()方法不能通过编译,是因为在基类中它并没抛出异常,但是在扩展类中抛了. 这个是不可以的.
• event()方法没有抛出异常,atBat()方法抛出的异常是基类异常说明的子集,这个都是允许的,因为在向上转型之后,并不会造成基类方法失效.
• 关于main()方法,注意,在向上转型之后,编译器会要求按照基类所抛出的异常来处理.

注意,在继承的过程中,编译器会要求对异常做强制说明. 但是这并不表示异常列表本身属于方法类型的一部分. 方法签名仅包括方法名和形参列表. 上面balabalabala那么多,其实就说明了一个问题,子类的异常说明列表必须要”小于等于”基类的. 结合之前说过,方法可以throws异常但是在方法体内不抛出. 那么这种限制就使得程序更加健壮.

构造器

异常发生的时候,最麻烦的事情是该清理的东西是否都清理了. 绝大多数情况下, 飞机在起飞和降落的时候最危险,对象在生成和销毁的时候最危险. 因为这都不是稳定状态. 如果构造器内部出现了异常,清理行为或许就不能正常工作了. 使用try-catch-finally结构都可以安全的解决这个问题. 但是如果是构造器就麻烦了.因为finally总会执行,如果在构造器中使用finally块来进行清理的话,那么创建的对象在构造器中就被清理了. 咋整???

1.public class InputFile {
2.    private BufferedReader in;
3.    public InputFile(String filename) throws Exception{
4.        try{
5.            in = new BufferedReader(new FileReader(filename));
6.        }catch (FileNotFoundException e) {
7.            // TODO: handle exception
8.            System.out.println("can not open the fire"+filename);
9.            throw e;
10.        }catch (Exception e) {
11.            // TODO: handle exception
12.            try{
13.                in.close();
14.            }catch (IOException e2) {
15.                // TODO: handle exception
16.                System.out.println("in.close() unsuccessful");
17.            }
18.            throw e;
19.        }finally {
20.            //没有操作
21.        }
22.    }
23.    public String getLine(){
24.        String s;
25.        try{
26.            s = in.readLine();
27.        }catch (IOException e) {
28.            // TODO: handle exception
29.            throw new RuntimeException("readline() failed");
30.        }
31.        return s;
32.    }
33.    public void dispose(){
34.        try {
35.            in.close();
36.            System.out.println("close success");
37.        } catch (IOException e2) {
38.            // TODO: handle exception
39.            throw new RuntimeException("in.close() failed");
40.        }
41.    }
42.}

注意3-22行的构造器. 如果FileReader的构造器实白了,抛出FileNotFoundException异常,对于这个异常,不需要关闭文件,因为文件还没有打开. 而其他捕获到异常的catch语句就需要关闭文件了. 做完本地处理之后,异常被重新抛出,对于构造器而言,这是很合适的做法. 因为这样不会误导调用者,让他认为已经构造成功了.
对于构造阶段就可能会抛出异常的类,最安全的做法是使用嵌套的try子句来处理.

1.public class Cleanup {
2.    public static void main(String[] args) {
3.        try {
4.            InputFile in = new InputFile("Cleanup.java");
5.            try{
6.                String s;
7.                int i =1;
8.                while((s=in.getLine())!=null){
9.                    //...
10.                }
11.            }catch (Exception e) {
12.                // TODO: handle exception
13.                System.out.println("caught exception in main");
14.                e.printStackTrace(System.out);
15.            }finally{
16.                in.dispose();
17.            }
18.        } catch (Exception e) {
19.            // TODO: handle exception
20.            System.out.println("input file construction failed");
21.        }
22.    }
23.}

第4行代码,如果构造实白直接会进入自己的catch语句块,也就是18行. 这样的话,dispose()语句也不会被调用. 而如果构造成功会进入内层try块执行. 在这种方法中,finally子句在构造失败的时候不会被执行. 而构造成功的时候总是会被执行. 但是,这种办法虽然能解决问题,但是在绝大部分情况下,还是需要清理对象的时候,立即进入finally块中.

1.class NeedCleanup {
2.    private static long counter = 1;
3.    private final long id = counter++;
4.
5.    public void dispose() {
6.        System.out.println("need cleanup " + id + " disposed");
7.    }
8.}
9.
10.class ConstructionException extends Exception {
11.
12.}
13.
14.class NeedCleanup2 extends NeedCleanup {
15.    public NeedCleanup2() throws ConstructionException {
16.
17.    }
18.}
19.
20.public class CleanupIdiom {
21.    public static void main(String[] args) {
22.    //section1
23.        NeedCleanup nc1 = new NeedCleanup();
24.        try {
25.
26.        } finally {
27.            nc1.dispose();
28.        }
29.    //section2
30.        NeedCleanup nc2 = new NeedCleanup();
31.        NeedCleanup nc3 = new NeedCleanup();
32.        try {
33.
34.        } finally {
35.            nc3.dispose();
36.            nc2.dispose();
37.        }
38.    //section3
39.        try {
40.            NeedCleanup2 nc4 = new NeedCleanup2();
41.            try {
42.                NeedCleanup2 nc5 = new NeedCleanup2();
43.                try {
44.                    // ....
45.                } finally {
46.                    nc5.dispose();
47.                }
48.            } catch (ConstructionException e) {
49.                System.out.println(e);
50.            }
51.
52.            finally {
53.                nc4.dispose();
54.            }
55.        } catch (ConstructionException e) {
56.            System.out.println(e);
57.        }
58.    }
59.}

section1 就是一个简单的try-finally原则. section2为了构造和清理,可以看到具有不能失败的构造器的对象组合在一起
section3展示了如何处理可以失败的构造器且需要清理的对象. (可绕死我了…)

异常的匹配

一句话,实在懒得写了,在抛出异常之后,异常处理程序会按照代码的书写顺序,找出”最近”的匹配上的处理代码. 这里所谓的匹配,包括其基类. 所以在书写的时候,最好按照”由小到大”的顺序来书写.

其他乱七八糟

异常处理的一个重要原则,在你知道如何处理的情况下才捕获它. 实际上异常处理的一个重要目标就是将错误处理的代码和发生错误的地点相分离.

TJI读书笔记16-异常处理