异常处理机制的初衷是将不可预期异常的处理代码和正常的业务逻辑处理代码分离，

因此绝不要使用异常处理来代替正常的业务逻辑判断。

若错误是可预料的，则必须提供处理错误的代码来处理错误，而不是抛出异常。

1. //异常  
2. package bin;  
3. import java.io.FileInputStream;  
4. import java.io.IOException;  
5. public class AccessExceptionMsg  
6. {  
7.     public static void main(String[] args)  
8.     {  
9.         try 
10.         {  
11.             FileInputStream fis = new FileInputStream("a.txt");  
12.         }  
13.         catch(IOException ioe)  
14.         {  
15.             //System.out.println(ioe.getMessage());  
16.             ioe.printStackTrace();  
17.         }     
18.     }     
19. }  
20. /*  
21.     getMessage():返回该异常的详细描述字符串  
22.     printStackTrace():将该异常的跟踪栈信息输出到标准错误输出。  
23.     printStackTrace(PrintStream s):将该异常的跟踪栈信息输出到指定输出流。  
24.     getStackTrace():返回该异常的跟踪栈信息。  
25. */ 
26. /*  
27.     结果：a.txt(系统找不到指定文件)【异常描述信息】  
28.                 java.io.FileNotFoundException:...【异常跟踪信息】  
29. */ 

异常处理语法结构中只有try块是必须的，catch块和finally块都是可选的，但是不能同时没有catch块和finally块，二者至少出现其一。'

finally:

   return语句强制方法返回，通常情况下，方法执行到return语句，程序立即结束该方法，但一定会先执行finally块里的代码，但若程序中有System.exit(1)退出虚拟机，finally不会被执行。

使用throws声明抛出异常:

使用throws声明抛出异常的思路是：当前方法不知道应该如何处理这种类型的异常，该异常应该由上一级调用者处理。

throws ExceptionClass1,ExceptionClass2...

*一旦使用throws语句声明抛出该异常，程序就无需使用try...catch块来捕获异常。*

 使用throws声明抛出异常时有一个限制：就是方法重写时的“两小”中一条规则：子类方法中声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相等，子类方法中不允许比父类方法声明抛出更多的异常。

使用throw抛出异常：

throw语句抛出的不是异常类，而是一个异常实例，且每次孩子能抛出一个异常实例。【throw ExceptionInstance】

*使用throw时一定要声明throws*声明异常

自定义异常类：

1. public class AuctionException extends Exception  
2. {  
3.     //异常类无参数的构造器  
4.     public AuctionException(){}  
5.     //带一个字符串参数的构造器  
6.     public AuctionException(String msg)  
7.     {  
8.         super(msg);   
9.     }     
10. } 

catch和throw同时使用：

1. /*  
2.     catch和throw同时使用  
3.     异常出现的当前方法中，程序只对异常进行部分处理，还有些  
4.     处理需要在该方法的调用者中才能完成，所以应该再次抛出异常，  
5.     这样就可以让该方法的调用者也能捕获到异常。  
6. */ 
7. public class TestAuction  
8. {  
9.     private double initPrice  = 30.0;  
10.     public void bid(String bidPrice) throws AuctionException  
11.     {  
12.         double d = 0.0;  
13.         try 
14.         {  
15.             d = Double.parseDouble(bidPrice);  
16.         }  
17.         catch(Exception e)  
18.         {  
19.             e.printStackTrace();//打印异常跟踪栈信息  
20.             throw new AuctionException("竞拍价必须是数值，不能包含其他字符！");     
21.         }  
22.         if(initPrice > d)  
23.         {  
24.             throw new AuctionException("竞拍价比起拍价低，不允许竞拍！");    
25.         }  
26.         initPrice = d;  
27.     }     
28.     public static void main(String[] args)  
29.     {  
30.         TestAuction ta = new TestAuction()  
31.         try 
32.         {  
33.             ta.bid("df");     
34.         }     
35.         catch(AuctionException ae)  
36.         {  
37.             //main方法再次捕捉到bid方法中的异常，并对该异常进行处理  
38.             System.out.println(ae.getMessage());      
39.         }  
40.     }  
41. } 

异常链：

1. //异常链：程序先捕获原始异常，然后抛出新的业务异常 
2. //        新的异常中包括对客户的提示 
3. package bin; 
4. public calSal throws SalException 
5. { 
6.     try 
7.     { 
8.         ... 
9.     } 
10.     catch(SQLException sqle) 
11.     { 
12.             throw new SalException(sqle); 
13.     }    
14.     catch(Exception) 
15.     { 
16.         throw new SalException(e);   
17.     } 
18. } 
19. class SalException extends Exception 
20. { 
21.     public SalException(){} 
22.     public SalException(String msg) 
23.     { 
24.         super(msg);  
25.     }    
26.     //创建一个可以接受Throwable参数的构造器 
27.     public SalException(Throwable t) 
28.     { 
29.         super(t); 
30.     } 
31. } 

java的异常跟踪栈

异常对象的printStackTrace方法用于打印异常的跟踪栈信息，根据printStackTrance方法的输入结果，我们可以找到异常的源头，并跟踪到异常一路触发的过程。