《Java编程思想》之异常处理

1、抛出异常之后

1).使用new在对象上创建异常对象

2).终止当前的执行路径

3).从当前环境中弹出对异常对象的引用

4).异常处理机制接管程序，并开始执行异常处理机制

2、异常处理理论上有两种基本模型

1).终止模型：一旦异常抛出，就表明错误无法挽回，也能回来继续执行。比较实用。

2).恢复模型：异常处理之后继续执行程序。但是可能导致“耦合”。

3、自定异常类（具有带参数的构造器）

class SimpleException extends Exception{
   public SimpleException(){}
   public SimpleException(String msg){
      super(msg);
   }
}
public class SimpleExceptionDemo{
   public void func() throws SimpleException{
      System.out.println("Throw SimpleExceptionfrom func().");
      throw new SimpleException();
   }
   public void func1() throws SimpleException{
      System.out.println("ThrowSimpleException from func1().");
      throw new SimpleException("Originated in func1()");
   }
   public static void main(String[] args){
      SimpleExceptionDemo sed = new SimpleExceptionDemo();
      try {
        sed.func();
      } catch (SimpleException e) {
        e.printStackTrace();
      }
      try {
        sed.func1();
      } catch (SimpleException e) {
        e.printStackTrace();
      }
   }
}

运行结果：

4、异常说明：实用关键字throws，告知客户端程序员可能会抛出的异常类型。

5、在定义抽象基类和接口时，可以throws一些实际上并不抛出的异常。这样做的好处：为异常先占个位子，以后就可以抛出这种异常而不用修改已有的代码。

6、捕获所有异常（最好放在处理程序列表的末位）：

catch (Exception e) {
   System.err.println("Caught an exception");
}

7、如果当前异常对象重新抛出，那么printStackTrace()方法显示的将是原来异常抛出点的调用栈信息，而非重新抛出点的信息。要想更新这个信息，可以调用fillInStackTrace()方法，这将返回一个Throwable对象，它是通过把当前调用栈信息填入原来那个异常对象而建立的。

8、

public static void main(String[] args) throws Throwable{
      try{
        throw new Throwable();
      }catch(Exception e){
        System.err.println("Caught inmain()");
      }
   }

因为Throwable是Exception的基类，所以下面程序中将不能再main()里捕获。

9、RuntimeException（或任何从它继承的异常）是一个特例，对于这种异常，编译器不需要异常说明。原因：

1).无法预料的错误。比如在你控制范围之外传递进来的null引用。

2).作为程序员，应该在代码中进行检查的错误。（比如对于ArrayIndexOutOfBoundsException,就得注意一下数组的大小了。）在一个地方发生的异常，常常会在另一个地方导致错误。

10、finally的作用：把除了内存之外的资源恢复到它们的初始状态。例如：已经打开的文件盒网络连接，在屏幕上画的图形，甚至可以是外部世界的某个开关。

11、异常丢失：

class FirstException extends Exception{
   public String toString(){
      return "The firstException.";
   }
}
class SecondException extends Exception{
   public String toString(){
      return "The secondException.";
   }
}
 
public class ErrorFinally{
   void firstFunc() throws FirstException{
      throw new FirstException();
   }
   void secondFunc() throws SecondException{
      throw new SecondException();
   }
   public static void main(String[] args) throws Exception{
      ErrorFinally error = new ErrorFinally();
      try {
        error.firstFunc();
      } finally{
        error.secondFunc();
      }
   }
}

运行结果：

    可以看到，FirstException不见了，它被finally里的SecondException取代了。

12、异常的限制：当覆盖方法的时候，只能抛出在基类方法的异常说明里列出的那些异常。这个限制很有用，因为这意味着，当基类使用的代码应用到其派生类对象的时候，一样能够工作(当然，这是面向对象的基本概念)，异常也不例外。

1).派生类构造函数的异常说明必须包含基类构造器的异常说明。

2).派生类构造器不能捕获基类构造器抛出的异常。(P275第三段最后一句怎么理解??)

3).派生类的方法可以不抛出异常，即使基类的方法有抛出异常。

4).派生类的方法可以抛出继承自"基类方法所抛出异常"的异常。

请看下面例子:

class BaseException extends Exception{}
class FuncException extends Exception{}
class OtherfuncException extends FuncException{}
class Base {
   Base() throws BaseException {
     
   }
   void func() throws FuncException {
      System.out.println("Base.func()");
   }
   void otherFunc() throws FuncException {
      System.out.println("Base.otherFunc()");
   }
}
public class InheritBase extends Base{
   //派生类构造函数的异常说明必须包含基类构造器的异常说明
   public InheritBase() throws BaseException {
      super();
   }
   //派生类的方法可以不抛出异常，即使基类的方法有抛出异常。
   void func(){
      System.out.println("InheritBase.func");
   }
   //派生类的方法可以抛出继承自"基类方法所抛出异常"的异常，如下OtherfuncException继承自FuncException
   //因为异常处理程序能捕获FuncException就一定能捕获OtherfuncException。
   void otherFunc() throws OtherfuncException{
      System.out.println("InheritBase.otherFunc()");
   }
   public static void main(String[] args){
      try {
        Base ib = new InheritBase();
        ib.func();
      } catch (BaseException e) {
        System.err.println("Caught BaseException.");
      } catch (FuncException e) {
        System.err.println("Caught funcException.");
      }
   }
}

13、把异常传给控制台

public static void main(String[] args) throws Exception{
     
}

14、把“被检查的异常”转换为“不检查的异常”：把“被检查的异常”这种功能给屏蔽掉。

1).

try {
       
} catch (BeCheckedException e) {
   throw new RuntimeException(e);
}

这样做的好处：不用“吐下”异常（“吐下”后异常完全消失），也不必把它放到方法的异常说明里（throws），而异常链还能保证你不会丢失任何原始异常的信息。

2).你也可以不写try-catch字句和/或异常说明，直接忽略异常，让它沿着调用栈往上“冒泡”。同时，还可以用getCause()捕获并处理特定的异常，如下例子：

class ZeroException extends Exception{}
class FirstException extends Exception{}
class secondException extends Exception{}
class SomeOtherException extends Exception{}
//把”被检查的异常“包装起来
class WrapCheckException{
   void throwRuntimeException(int type){
      try{
        switch(type){
           case 0: throw new ZeroException();
           case 1: throw new FirstException();
           case 2: throw new secondException();
           default: return;
        }
      }catch(Exception e){
        throw new RuntimeException(e);
      }
   }
}
public class TurnOffChecking{
   public static void main(String[] args){
      WrapCheckException wce = new WrapCheckException();
      wce.throwRuntimeException(3);
      for(int i = 0; i < 4; i++){
        try{
           if(i < 3)
              wce.throwRuntimeException(i);
           else
              throw new SomeOtherException();
        }catch(SomeOtherException e){
           System.out.println("SomeOtherException:" + e);
        }catch(RuntimeException e){
           try {
              //用getCause捕获特定异常
              throw e.getCause();
           } catch (ZeroException e1) {
              System.out.println("ZeroException:" + e1);
           } catch (FirstException e1) {
              System.out.println("FirstException:" + e1);
           } catch (secondException e1) {
              System.out.println("secondException:" + e1);
           } catch (Throwable e1) {
              System.out.println("Throwable:" + e1);
           }
        }
      }
   }
}

运行结果：

1).WrapCheckException. throwRuntimeException()把不同的异常包装进了RuntimeException对象。

2).可以不用try块就可以调用throwRuntimeException()，但是，也可以使用try块捕获你想捕获的异常。

3).程序中把getCause()的结果（也就是被包装的那个原始异常）抛出来，然后用它们自己的catch子句进行处理。

 以上内容整理自《Java编程思想》，若有遗漏，请您不吝指出。

觉得自己进度有点慢，多么想一口气把这本书看完。我还有几本？17天。现在才267页。我得加速！！