异常处理必知

在可能会出现exception的地方，要使用try－catch或者throws或者两者都要。判断依据是：
如果对可能出现的exception不想被外部（方法的调用者）知道，就在方法内部try－catch掉这个exception；
如果希望外部知道，则在catch到之后把exception直接抛出或者抛出自定义的exception。 

一、异常的种类 
   
java异常可以分成两大类：
1、Exception和RuntimeException(虽然RuntimeException是从Exception继承的)。exception异常代表“无法避免的异常”  如io异常,往往这类异常是由于外部原因造成的，程序本身无法保证他们不发生，所以这类异常必须捕获。如果在函数内部无法处理这个异常必须再次抛出（在函数后面用throws语句），如果什么都不做就出现编译错误。
     
2、runtimexception是指“可以避免的异常”，如  null引用异常，这类异常都是由程序内部原因造成的，是可以避免的。对于这类异常可以忽略他们，但一旦发生程序就会异常终止。这类异常对debug非常有帮助，当然，如果需要也可以catch。 
 
另外，有些地方即使不会有exception，但是从商业逻辑上是错误的、非预期的，也可以抛出user  exception。例如，用户输入非法，bank  account非法透支等等。 

二、主要原则 
 
   处理意外的一个重要原则，就是要么处理，要么接着抛，决不能吃掉（You  either  handle  it,  or  throw  it.  You  don’t  eat  it.）这就是说，当你捕获一个异常之后，必须决定是否立即处理这个异常，或者继续抛出这个异常（或者另一个自定义异常），以便由调用的客户端捕获之。当客户端捕获到以后，又会继续进行类似的判断。 
 
一般来说，GUI端是要处理异常的，比如JSP捕获到异常之后，需要先是给用户一个友好的出错信息，而不要给出系统的出错信息。系统的出错信息一方面不太友好，另一方面提供了太多的系统信息，容易被恶意用户用来攻击系统。换句话说，所有的异常最终必须有一个终极的处理者，这就是GUI。至于中间的环节，比如在服务器端运行的JavaBean是否要处理捕获到的异常，还是继续抛出所捕获的异常，需要视具体情况处理。  
 
除非你想把异常处理的责任交给调用者，一般不用throws。  比如你要读入一些文件，如果你想通知调用者，让调用者决定如何处理这个异常，你就把这个异常throws给调用者；如果你知道应该如何处理这个异常，或者你想把异常马上解决，你可以就地catch她。
这完全取决于你想把异常自己立即处理还是想把处理责任返回给调用者。取决于你的程序的结构和要求。 
 
需要注意的有： 
1、如果无法处理某个异常，那就不要捕获它。   
2、如果捕获了一个异常，请不要胡乱处理它。   
3、尽量在靠近异常被抛出的地方捕获异常。   
4、在捕获异常的地方将它记录到日志中，除非您打算将它重新抛出。   
5、按照您的异常处理必须多精细来构造您的方法。   
6、需要用几种类型的异常就用几种，尤其是对于应用程序异常。   

 

三、异常嵌套和捕获适当的异常 
 
按照Java语言的定义，所谓异常（Exception）指的就是向调用方法（calling  method）表示发生非正常情况的习惯方式。下面讨论两种在处理异常时可兹利用的技术：异常嵌套和捕获适当的异常。 
 
异常嵌套 
  
你在试图捕获异常并打算扔出异常时该采取什么措施呢？同时，你希望原始的异常信息可用吗？  不管是新的异常是chekced异常还是unChecked异常。我们都必须考虑异常的嵌套问题。
public void methodA() throws ExceptionA{   
         …         
          throw new ExceptionA();        
}   
 
方法methodA声明会抛出ExceptionA.
 
public void methodB() throws ExceptionB
   methodB声明会抛出ExceptionB,当在methodB方法中调用methodA时，如何将ExceptionA继续往上抛出。一个办法是把methodB声明会抛出ExceptionA.但这样已经改变了MethodB的方法签名。一旦改变，则所有调用methodB的方法都要进行改变。
   另一个办法是把ExceptionA封装成ExceptionB，然后再抛出。如果我们不把ExceptionA封装在ExceptionB中，就丢失了根异常信息，使得无法跟踪异常的原始出处。
public void methodB()throws ExceptionB{   
   try{   
      methodA();   
      ……   
   }catch(ExceptionA ex){   
     throw new ExceptionB(ex); //把ExceptionA封装成ExceptionB，然后再抛出
   }   
}  
 
   如上面的代码中，ExceptionB嵌套一个ExceptionA.我们暂且把ExceptionA称为“起因异常”,因为ExceptionA导致了ExceptionB的产生。这样才不使异常信息丢失。所以我们在定义一个新的异常类时，必须提供这样一个可以包含嵌套异常的构造函数。并有一个私有成员来保存这个“起因异常”。
java 代码
public Class ExceptionB extends Exception{   
private Throwable cause;   
    
public ExceptionB(String msg, Throwable ex){   
 super(msg);   
 this.cause = ex;   
}   
    
public ExceptionB(String msg){   
 super(msg);   
}   
    
public ExceptionB(Throwable ex){   
 this.cause = ex;   
}   
}   
当然，我们在调用printStackTrace方法时，需要把所有的“起因异常”的信息也同时打印出来。
所以我们需要覆写printStackTrace方法来显示全部的异常栈跟踪。包括嵌套异常的栈跟踪。
public void printStackTrace(PrintStrean ps){   
  if(cause == null){   
    super.printStackTrace(ps);   
  }else{   
     ps.println(this);   
     cause.printStackTrace(ps);   
  }   
}   
 
一个完整的支持嵌套的checked异常类源码如下。我们在这里暂且把它叫做NestedExceptionpublic。
 NestedException extends Exception{   
  private Throwable cause;   
  public NestedException (String msg){   
    super(msg);   
  }   
    
public NestedException(String msg, Throwable ex){   
 super(msg);   
 This.cause = ex;   
}   
    
public Throwable getCause(){   
 return (this.cause == null ? this :this.cause);   
}   
    
public getMessage(){   
 String message = super.getMessage();   
 Throwable cause = getCause();   
   if(cause != null){   
     message = message + “;nested Exception is ” + cause;   
   }   
 return message;   
}
public void printStackTrace(PrintStream ps){   
 if(getCause == null){   
    super.printStackTrace(ps);   
       
 }else{   
 ps.println(this);   
 getCause().printStackTrace(ps);   
 }   
}   
    
public void printStackTrace(PrintWrite pw){   
 if(getCause() == null){   
    super.printStackTrace(pw);   
 }   
 else{   
    pw.println(this);   
    getCause().printStackTrace(pw);   
 }   
}   
public void printStackTrace(){   
 printStackTrace(System.error);   
}   
}   
    
捕获适当的异常 
正确地处理异常并不是一项轻松的任务，这是因为异常的处理有时会导致程序出现其他不明行为。不过，以下三条规则可以帮助你避免错误处理异常所可能遭遇的风险。 
 
规则  #1:  总是捕获扔出异常的类型而不要理睬异常的超类。 
 
规则  #  2:  决不让catch块留空。在很多情况下虽然确实编写了try/catch块但在代码的catch部分却什么都没有做。或者，如果采用了日志API（Logging  API），那么请编写代码把异常写到日志中。 
 
规则  #  3:  决不扔出Exception基类的实例。开发人员应当总是扔出自己创建的异常类。 
 
 
以上提到的两种技术在处理异常时还可能用得更好、更适当。嵌套技术令异常扔到另一异常的内部，而捕获适当的异常令程序调试大大简化。