Java：如何处理异常

在处理异常时，应该区分 checked 异常和 unchecked 异常。对于 checked 异常，我们应该提供健壮的异常恢复机制，而对于 unchecked 异常，这就是编程错误即 bug ，应该在调试阶段很好的发现和处理它们。

1. Java 异常层次结构

上图（注：该图引自 [url]http://dev2dev.bea.com.cn/techdoc/200702364792.html[/url] ）标出了 Java 异常层次结构，也指出了哪些异常是 unchecked ，哪些异常是 checked 。下面给出几段常见的异常处理代理，试图总结日常开发中应该如何处理异常。

2. 针对 checked 异常的恢复机制

checked 异常并不是编程错误，它的出现是软件运行阶段所不可避免的。最常见的这类异常如 socket 连接超时。

对于此类异常，我们应该在程序的运行态下试图从异常中恢复过来。下面这段代码 (Recover.java) 的主要逻辑是，对目标值 protected int current 进行判断，如果该值大于 2 则成功，否则抛出 NotBigEnoughException 异常。

在执行程序的过程中，在每次 catch 到 NotBigEnoughException 异常时，我们对 current 值递增，试图从异常中恢复过来。

NotBigEnoughException.java

package com.zj.exception.types;   public class NotBigEnoughException extends Exception {     public NotBigEnoughException() {        super ();     }       public NotBigEnoughException(String msg) {        super (msg);     } }

 

Recover.java

package com.zj.exception; import com.zj.exception.types.NotBigEnoughException;   public class Recover {     protected int current = 0;     protected boolean accept = false ;       public Recover() {}       public Recover( int cur) {        current = cur;     }       public void increment() {        ++ current ;     }       public boolean passed() {        return accept ;     }       public void passing() throws NotBigEnoughException {        if ( current > 2) {            accept = true ;            System. out .println( "accept " + current );        } else            throw new NotBigEnoughException( "reject " + current );     }       public static void main(String[] args) {        Recover re = new Recover();        while (!re.passed()) {            try {               re.passing();            } catch (NotBigEnoughException e) {               System. out .println(e);               re.increment();            }        }     } }

结果：

com.zj.exception.types.NotBigEnoughException : reject 0

com.zj.exception.types.NotBigEnoughException : reject 1

com.zj.exception.types.NotBigEnoughException : reject 2

accept 3

3. 继承异常

在子类继承父类的情况下，子类 override 方法的异常声明只能取自（小于等于）父类该方法的异常声明；对于子类构造方法的异常声明必须包含（大于等于）父类构造方法的异常声明。

类 Inheritor 继承自类 Recover ， 它的方法 passing() 试图声明一个父类没有的异常 UnknowException ， 这样做是不允许的。

UnknowException.java

package com.zj.exception.types;   public class UnknowException extends Exception {     public UnknowException() {        super ();     }       public UnknowException(String msg) {        super (msg);     } }

error in: Inheritor.java

//couldn't throws new exceptions where not found in its base class public void passing() throws NotBigEnoughException, UnknowException {     if ( current > 2) {        accept = true ;        System. out .println( "accept " + current );     } else if ( current >= 0)        throw new NotBigEnoughException( "reject " + current );     else        throw new UnknowException( "i don't know how to deal with "               + current ); }

之所以覆盖这个方法的目的是对父类的 passing() 方法做进一步扩展，对 0<=current<=2 的情况抛出 NotBigEnoughException ， 而对 current<0 的情况则抛出一个新的异常 UnknowException 。

此时，提供两种解决方法。

方法一，使用恢复异常机制， overrding passing （）方法，这样可以处理掉所有的异常，因此不需要异常声明。

ok in: Inheritor.java

//sure passing(),so not have to throw exceptions public void passing(){     while (!passed()) {        try {            super .passing();        } catch (NotBigEnoughException e) {            increment();        }     } }

方法二，写一个加强的 passing （）方法，即 fortifiedPassing() ， 对于在父类 passing （）中捕获的异常，进行再判断。如果是 0<=current<=2 的情况则重新抛出 NotBigEnoughException ，如果是 current<0 的情况则抛出一个新的异常 UnknowException 。

ok in: Inheritor.java

public void fortifiedPassing() throws NotBigEnoughException, UnknowException{     try {        super .passing();     } catch (NotBigEnoughException e) {        if ( current >=0)            throw e;        else            throw new UnknowException( "i don't know how to deal with "                   + current );     } }

 

Inheritor.java

package com.zj.exception; import com.zj.exception.types.NotBigEnoughException; import com.zj.exception.types.UnknowException;   public class Inheritor extends Recover {     public Inheritor( int cur) {        super (cur);     }       //couldn't throws new exceptions where not found in its base class     /**     public void passing() throws NotBigEnoughException, UnknowException {        if (current > 2) {            accept = true;            System.out.println("accept " + current);        } else if (current >= 0)            throw new NotBigEnoughException("reject " + current);        else            throw new UnknowException("i don't know how to deal with "                   + current);     }*/         //sure passing(),so not have to throw exceptions     public void passing(){        while (!passed()) {            try {               super .passing();            } catch (NotBigEnoughException e) {               increment();            }        }     }         public void fortifiedPassing() throws NotBigEnoughException, UnknowException{        try {            super .passing();        } catch (NotBigEnoughException e) {            if ( current >=0)               throw e;            else               throw new UnknowException( "i don't know how to deal with "                      + current );        }     }       public static void main(String[] args) {        // not required try-catch        new Inheritor(3).passing();        new Inheritor(1).passing();        new Inheritor(-1).passing();           //no exceptions        try {            new Inheritor(3).fortifiedPassing();        } catch (NotBigEnoughException e) {            e.printStackTrace();        } catch (UnknowException e) {            System. out .println(e);        }        //NotBigEnoughException:        try {            new Inheritor(1).fortifiedPassing();        } catch (NotBigEnoughException e) {            e.printStackTrace();        } catch (UnknowException e) {            System. out .println(e);        }        //UnknownException:        try {            new Inheritor(-1).fortifiedPassing();        } catch (NotBigEnoughException e) {            e.printStackTrace();        } catch (UnknowException e) {            System. out .println(e);        }     } }

结果：

accept 3

accept 3

accept 3

accept 3

com.zj.exception.types.UnknowException : i don't know how to deal with -1

com.zj.exception.types.NotBigEnoughException : reject 1

    at com.zj.exception.Recover.passing( Recover.java:28 )

    at com.zj.exception.Inheritor.fortifiedPassing( Inheritor.java:38 )

    at com.zj.exception.Inheritor.main( Inheritor.java:63 )

4.RuntimeException 与包装异常

RuntimeException 是 unhecked 异常，它们由 JVM 抛出（你也可以抛出它），并且不必在异常声明（ throws ）中列出。

如果 RuntimeException 没有被 catch 而到达 mian （）方法时，那么在程序退出前会自动调用该异常的 printStackTrace() 方法，打印该异常。

RuntimeException 代表的是编程错误（如 0 除数，数组越界），是应该在调试阶段解决的。

当你在捕获某些异常，而不知道该如果处理时，你可以将它包装为 RuntimeException ，这样在后续的方法调用过程中就不用声明 (throws) 该方法了。

在类 Wrapper 中，我们 override fortifiedPassing() 方法，并将它可能抛出的异常包装为 RuntimeException 。

Wrapper.java

package com.zj.exception; import com.zj.exception.types.NotBigEnoughException; import com.zj.exception.types.UnknowException;   public class Wrapper extends Inheritor {     public Wrapper( int cur) {        super (cur);     }       public void fortifiedPassing() {        try {            super .fortifiedPassing();        } catch (NotBigEnoughException e) {            throw new RuntimeException(e);        } catch (UnknowException e) {            throw new RuntimeException(e);        }     }       public static void main(String[] args) {        // not required try-catch        new Wrapper(3).fortifiedPassing();        new Wrapper(1).fortifiedPassing();        new Wrapper(-1).fortifiedPassing();     } }

结果：

accept 3

Exception in thread "main" java.lang.RuntimeException : com.zj.exception.types.NotBigEnoughException : reject 1

    at com.zj.exception.Wrapper.fortifiedPassing( Wrapper.java:14 )

    at com.zj.exception.Wrapper.main( Wrapper.java:23 )

Caused by: com.zj.exception.types.NotBigEnoughException : reject 1

    at com.zj.exception.Recover.passing( Recover.java:28 )

    at com.zj.exception.Inheritor.fortifiedPassing( Inheritor.java:38 )

    at com.zj.exception.Wrapper.fortifiedPassing( Wrapper.java:12 )

    ... 1 more