异常处理: 深入理解java异常处理机制

 引子

       尝试...赶上...最后恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单，听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案，也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。

[java]   查看纯 文本  

1. 包 测试;  
2.   
3. 公共类 TestException {   
4.     public  TestException（）{  
5.     }  
6.   
7.     布尔 testEx（）  抛出 异常{  
8.         boolean  ret =  true ;  
9.         尝试 {  
10.             ret = testEx1（）;  
11.         }  捕获 （例外五）{  
12.             System.out.println（“testEx，catch exception” ）;  
13.             ret =  false ;  
14.             扔 e;  
15.         }  finally  {  
16.             System.out.println（“testEx，finally; return value =”  + ret）;  
17.             返回 ret;  
18.         }  
19.     }  
20.   
21.     布尔 testEx1（）  抛出 异常{  
22.         boolean  ret =  true ;  
23.         尝试 {  
24.             ret = testEx2（）;  
25.             如果 （！ret）{  
26.                 返回false ;   
27.             }  
28.             System.out.println（“testEx1，在尝试结束时” ）;  
29.             返回 ret;  
30.         }  捕获 （例外五）{  
31.             System.out.println（“testEx1，catch exception” ）;  
32.             ret =  false ;  
33.             扔 e;  
34.         }  finally  {  
35.             System.out.println（“testEx1，finally; return value =”  + ret）;  
36.             返回 ret;  
37.         }  
38.     }  
39.   
40.     布尔 testEx2（）  抛出 异常{  
41.         boolean  ret =  true ;  
42.         尝试 {  
43.             int  b =  12 ;  
44.             int  c;  
45.             for  （int  i =  2 ; i> = - 2 ; i-- ）{  
46.                 c = b / i;  
47.                 System.out.println（“i =”  + i）;  
48.             }  
49.             返回true ;   
50.         }  捕获 （例外五）{  
51.             System.out.println（“testEx2，catch exception” ）;  
52.             ret =  false ;  
53.             扔 e;  
54.         }  finally  {  
55.             System.out.println（“testEx2，finally; return value =”  + ret）;  
56.             返回 ret;  
57.         }  
58.     }  
59.   
60.     public static void  main（String [] args）{    
61.         TestException testException1 =  new  TestException（）;  
62.         尝试 {  
63.             testException1.testEx（）;  
64.         }  捕获 （例外五）{  
65.             e.printStackTrace（）;  
66.         }  
67.     }  
68. }  

你的答案是什么？是下面的答案吗？

i = 2
i = 1 testEx2，最后
捕获异常
testEx2; 返回值= false testEx1，最后
捕获异常
testEx1; 返回值= false testEx，最后
捕获异常
testEx; 返回值= false

如果你的答案真的如上面所说，那么你错啦。^ _ ^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改，执行，测试，你会。发现有很多事情不是原来想象中的那么简单的现在公布正确答案：

i = 2
i = 1 testEx2，最后
捕获异常
testEx2; 返回值= false
testEx1，最后; 返回值= false
testEx，最后; 返回值= false

注意说明：

最后语句块不应该出现应该出现return。上面的return ret最好是其他语句来处理相关逻辑。

 2.JAVA异常

   异常指不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程.Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出​​现在一段编码中的错误条件。当条件生成时，错误将引发异常。

      Java的异常类层次结构图：

        

                                                                    图1 Java异常类层次结构图

   

        在Java中，所有的异常都有一个共同的祖先Throwable（可抛出）.Throwable指定代码中可用异常传播机制通过Java应用程序传输的任何问题的共性。Throwable
       ：  有两个重要的子类：Exception （异常）和错误（错误），二者都是Java异常处理的重要子类，各自都包含大量子类。

       错误（错误）：是程序无法处理的错误，表示运行应用程序中较严重问题。例如，Java虚拟机出现的问题。 Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

。这些错误表示故障发生于虚拟机自身，或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError），类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的Java异常状况。在Java中，错误通过Error的子类描述。

       异常（异常）：是程序本身可以处理的异常。

       Exception类有一个重要的子类RuntimeException.RuntimeException类及其子类表示“JVM常用操作”引发的错误。例如，若试图使用空值对象引用，除数为零或数组越界，则分别引发运行时异常NullPointerException，ArithmeticException）和ArrayIndexOutOfBoundException。

   注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

   通常，Java的异常（包括异常和错误）分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。可查异常（编译器要求必须处理的异常）：正确的程序在运行中，很容易出现的，情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，一旦而且发生这种异常状况，就必须采取某种方式进行处理。
      

      除了RuntimeException的及其子类以外，其他的异常类及其子类都属于可查异常。这种异常的特点是Java的编译器会检查它，也就是说，当程序中可能出现这类异常，要么用的try-catch语句捕获它，要么用抛出子句声明抛出它，否则编译不会通过。

     不可查异常（编译器不要求强制处置的异常）：包括运行时异常（RuntimeException的与其子类）和错误（错误）。

     异常这种异常分两大类运行时异常和非运行时异常（编译异常）。程序中应当尽可能去处理这些异常。

       运行时异常：都是RuntimeException类及其子类异常，如NullPointerException（空指针异常），IndexOutOfBoundsException（下标越界异常）等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误，程序应该从逻辑角度尽可能避免这类。

      运行时异常的特点是Java的编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用的try-catch语句捕获它，也没有用抛出子句声明抛出它，也会编译通过。
非运行时异常  （编译异常）： 。是的RuntimeException以外的异常，类型上都属于异常类及其子类从程序语法角度，如果不处理，程序就不能编译通过。如IOException异常，的SQLException等以及用户自定义的异常异常，情况一般下不自定义检查异常。       

    

 4.处理异常机制

        在Java应用程序中，异常处理机制为：抛异常，捕捉异常。

        抛出异常：。当一个方法出现错误引发异常时，方法创建异常对象并交付运行时，异常对象中包含了异常类型和并执行。

        捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（异常处理程序）。异常处理是异常发生时依次存留在调用栈中的方法的集合。器所能处理的异常类型与方法抛出异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直到找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

        对于运行时异常，错误或可查异常，Java的技术所要求的异常处理方式有所不同。

        由于运行时异常的不可查性，为了更合理，更容易地实现应用程序，Java的规定，运行时异常将由Java的运行时系统自动抛出，允许应用程序忽略运行时异常。

       对于方法运行中可能出现的错误，当运行方法不欲捕捉时，爪哇允许该方法不做任何抛出声明。因为，大多数错误异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。

       对于所有的可查异常，Java的规定：一个方法必须捕捉，或者声明抛出方法之外也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。

        能捕捉异常的方法，需要提供相应类型的异常处理器。所捕捉的异常，可能是由于自身语句所引发并抛出的异常，也可能是由某个调用的方法或者Java运行时系统等异的异常。也就是说，一个方法所能捕捉的异常，一定是Java的代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。

         任何的Java代码都可以抛出异常，如：自己编写的代码，来自Java的开发环境包中代码，或者Java的运行时系统无论是谁，都可以通过Java的的抛出语句抛出异常。

        从方法中抛出的任何异常都必须使用抛出子句。

        捕捉异常通过的try-catch语句或者的try-catch-终于语句实现。

         总体来说，Java的规定：对于可查异常必须捕捉，或者声明抛出允许忽略不可查的RuntimeException的和错误。

4.1捕获异常：尝试，抓住和最后

1.try捕语句

     在的Java中，异常通过的try-catch语句捕获其一般语法形式为：

[java]   查看纯 文本  

1. 尝试 {  
2.     //可能会发生异常的程序代码  
3. }  catch  （Type1 id1）{  
4.     //捕获并处置尝试抛出的异常类型Type1  
5. }  
6. catch  （Type2 id2）{  
7.      //捕获并处置试图抛出的异常类型类型2  
8. }  

       关键词尝试后的一对大括号将一块可能发生异常的代码包起来，称为监控区域.Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之外，由Java运行时系统试图寻找匹配的追赶子句以捕获异常。若有匹配的捕捉子句，则运行其异常处理代码，的try-catch语句结束。

       匹配的原则是：如果抛出的异常对象属于追赶子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与追赶块捕获的异常类型相匹配。

例1   捕捉投语句抛出的“除数为0”的异常。

[java]   查看纯 文本  

1. 公共类 TestException {   
2.     public static void  main（String [] args）{    
3.         int  a =  6 ;  
4.         int  b =  0 ;  
5.         尝试 {  //尝试监控区域  
6.               
7.             如果 （b ==  0 ）  抛出新的 ArithmeticException（）; //通过抛出语句抛出异常   
8.             System.out.println（“a / b的值是：”  + a / b）;  
9.         }  
10.         catch  （ArithmeticException e）{  //捕捉捕捉异常  
11.             System.out.println（“程序出现异常，变量b不能为0.” ）;  
12.         }  
13.         System.out.println（“程序正常结束。” ）;  
14.     }  
15. }  

运行结果：程序出现异常，变量b不能为0。

                    程序正常结束。

        例1在尝试监控区域通过if语句进行判断，当“除数为0”的错误条件成立时引发ArithmeticException异常，创建ArithmeticException异常对象，并由throw语句将异常抛给Java运行时系统，由系统寻找匹配的异常处理器捕获和运行相应异常处理代码，打印输出“程序出现异常，变量b不能为0.”。try-catch语句结束，继续程序流程。

        事实上，“除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不需要使用抛语句。

例2   捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常。

[java]   查看纯 文本  

1.     public static void  main（String [] args）{    
2.         int  a =  6 ;  
3.         int  b =  0 ;  
4.         尝试 {  
5.             System.out.println（“a / b的值是：”  + a / b）;  
6.         }  catch  （ArithmeticException e）{  
7.             System.out.println（“程序出现异常，变量b不能为0.” ）;  
8.         }  
9.         System.out.println（“程序正常结束。” ）;  
10.     }  
11. }  

运行结果：程序出现异常，变量b不能为0。

                  程序正常结束。

例2中的语句：

System.out.println（“a / b的值是：”+ a / b）;

      在运行中出现“除数为0”的错误，引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域，转而匹配合适的异常处理器捕获，并执行相应的异常处理代码。

      由于检查运行时异常的代价远大于捕捉异常所带来的益处，运行时异常不可查的.java编译器允许忽略运行时异常，一个方法可以既不捕捉，也不声明抛出运行时异常。

例3   不捕捉，也不声明抛出运行时异常。

[java]   查看纯 文本  

1. 公共类 TestException {   
2.     public static void  main（String [] args）{    
3.         int  a，b;  
4.         a =  6 ;  
5.         b =  0 ; //除数b的值为0  
6.         System.out.println（a / b）;  
7.     }  
8. }  

运行结果：

线程“main”java.lang.ArithmeticException中的异常：/ by零
在Test.TestException.main（TestException.java:8）

例4   程序可能存在除数为0异常和数组下标越界异常。

[java]   查看纯 文本  

1. 公共类 TestException {   
2.     public static void  main（String [] args）{    
3.         int [] intArray =  new int [ 3 ];   
4.         尝试 {  
5.             for  （int  i =  0 ; i <= intArray.length; i ++）{  
6.                 intArray [i] = i;  
7.                 System.out.println（“intArray [”  + i +  “] =”  + intArray [i]）;  
8.                 System.out.println（“intArray [”  + i +  “]模”  +（i -  2 ）+  “的值：”  
9.                         + intArray [i]％（i -  2 ））;  
10.             }  
11.         }  catch  （ArrayIndexOutOfBoundsException e）{  
12.             System.out.println（“intArray数组下标越界异常。” ）;  
13.         }  catch  （ArithmeticException e）{  
14.             System.out.println（“除数为0异常。” ）;  
15.         }  
16.         System.out.println（“程序正常结束。” ）;  
17.     }  
18. }  

运行结果：

intArray [0] = 0

intArray [0]模-2的值：0

intArray [1] = 1

intArray [1]模-1的值：0

intArray [2] = 2

除数为0异常。

程序正常结束。

      例4程序可能会出现除数为0异常，还可能会出现数组下标越界异常。

[java]   查看纯 文本  

1. catch  （ArithmeticException e）{  
2.       System.out.println（“除数为0异常。” ）;  
3.  }  

       需要注意的是，一旦某个捕捉捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个的try-catch语句结束。其他的抓子句不再有匹配和捕获异常类型的机会。

      Java通过异常类描述异常类型，异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子句放在前面，同时尽量将捕获相对高层的异常类的追赶子句放在后面。否则，捕获底层异常类的追赶子句将可能会被屏蔽。

      RuntimeException异常类包括运行时各种常见的异常，ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此，RuntimeException异常类的catch子句应该放在最后面，否则可能会屏蔽其后的特定异常处理或引起编译错误。

2. try-catch-finally语句

      的try-catch语句还可以包括第三部分，就是最后子句它表示无论是否出现异常，都应当执行的内容。尝试-catch-finally程序语句的一般语法形式为：

[java]   查看纯 文本  

1.               尝试 {  
2.     //可能会发生异常的程序代码  
3. }  catch  （Type1 id1）{  
4.     //捕获并处理尝试抛出的异常类型Type1  
5. }  catch  （Type2 id2）{  
6.     //捕获并处理尝试抛出的异常类型Type2  
7. }  finally  {  
8.     //无论是否发生异常，都将执行的语句块  
9. }  

例5   带终于子句的异常处理程序。

[java]   查看纯 文本  

1. 公共类 TestException {   
2.     public static void  main（String args []）{    
3.         int  i =  0 ;  
4.         String greetings [] = {  “Hello world！” ，  “Hello World !!” ，  
5.                 “ 你好，世界 ！！！”  };  
6.         而 （i <  4 ）{  
7.             尝试 {  
8.                 //特别注意循环控制变量i的设计，避免造成无限循环  
9.                 的System.out.println（问候[I ++]）;  
10.             }  catch  （ArrayIndexOutOfBoundsException e）{  
11.                 System.out.println（“数组下标越界异常” ）;  
12.             }  finally  {  
13.                 System.out.println（“--------------------------” ）;  
14.             }  
15.         }  
16.     }  
17. }  

运行结果：

你好，世界 ！

--------------------------

你好，世界 ！！

--------------------------

你好，世界 ！！！

--------------------------

数组下标越界异常

--------------------------

     在例5中，请特别注意尽量子句中语句块的设计，如果设计为如下，将会出现死循环如果设计为：

[java]   查看纯 文本  

1. 尝试 {  
2.       System.out.println（问候语[i]）; 我++;  
3. }  

小结：

try块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。catch
块：用于处理尝试捕获到的异常。finally
块：无论是否捕获或处理异常，最终块里的语句都会被执行。当在试块或捕捉块中遇到返回语句时，终于语句块将在方法返回之前被执行。在以下4种特殊情况下，终于块不会被执行：
1）在最后语句块中发生了异常
。2）在前面的代码中用了System.exit（）退出程序
。3）程序所在的线程死亡
。

3. try-catch-finally规则（异常处理语句的语法规则）：

1）必须在try之后添加catch或finally块.try块后可以同时接catch和finally块，但至少有一个块
。2）必须遵循块顺序：若代码同时使用catch和finally块，则必须将catch块放在try块之后
。3）catch块与相应的异常类的类型相关
。4）一个try块可能有多个catch块。若如此，则执行第一个匹配块。即Java虚拟机会把异常类的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的catch代码块
5）套的try-catch-最后结构。
6）在的try-catch-最后结构中，可重新抛出异常。
7）除了下列情况，总将执行最后做为结束：JVM过早终止（调用System.exit（INT ））;在finally块中抛出一个未处理的异常;计算机断电，失火或遭遇病毒攻击。

4. try，catch，finally语句块的执行顺序：

1）当尝试没有捕获到异常时：尽量语句块中的语句逐一被执行，程序将跳过捕语句块，执行最后语句块和其后的语句;

2）当尝试捕获到异常，赶上语句块里没有处理此异常的情况：当尝试语句块里的某条语句出现异常时，而没有处理此异常的捕获语句块时，此异常将会抛给JVM处理，最后语句块里的语句还是会被执行，但最后语句块后的语句不会被执行;

3）当尝试捕获到异常，赶上语句块里有处理此异常的情况：在尝试语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到捕捉语句块，并与捕捉语句块逐一匹配，找到与之对应的处理程序，其他的捕捉语句块将不会被执行，而尝试语句块中，出现异常之后的语句也不会被执行，抓语句块执行完后，执行最后语句块里的语句，最后执行最后语句块后的语句;

 图示尝试，捕捉，最后语句块的执行：

                                          图2   图示尝试，捕捉，最后语句块的执行

4.2抛出异常

      任何的Java代码都可以抛出异常，如：。自己编写的代码，来自Java的开发环境包中代码，或者Java的运行时系统无论是谁，都可以通过Java的的抛出抛出语句异常从方法中抛出的任何异常都必须使用抛出子句。

1.抛出异常

   如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用抛出子句来声明抛出异常。例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。

     throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为：

[java]   查看纯 文本  

1. methodname  引发 Exception1，Exception2，..，ExceptionN  
2. {  
3. }  

    方法名后的throws Exception1，Exception2，...，ExceptionN为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。例如：

[java]   查看纯 文本  

1. import  java.lang.Exception;  
2. 公共类 TestException {   
3.     static void  pop（）  throws  NegativeArraySizeException {   
4.         //定义方法并抛出NegativeArraySizeException异常  
5.         int [] arr =  new int [ - 3 ]; //创建数组   
6.     }  
7.   
8.     public static void  main（String [] args）{  //主方法    
9.         尝试 {  //尝试语句处理异常信息  
10.             弹出（）; //调用pop（）方法  
11.         }  catch  （NegativeArraySizeException e）{  
12.             System.out.println（“pop（）方法抛出的异常” ）; //输出异常信息  
13.         }  
14.     }  
15.   
16. }  

    使用抛出关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，名单最终但要有能够处理该异常的调用者。

    pop方法没有处理异常NegativeArraySizeException，而是由主函数来处理。抛出异常的规则：

    

    1）如果是不可查异常（unchecked exception），即 Error，RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

    2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

    3）仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

    4）调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

    例如：

[java]   查看纯 文本  

1. void  method1（）  抛出 IOException {}   //合法    
2.    
3. //编译错误，必须捕获或声明抛出IOException异常    
4. void  method2（）{    
5.   方法1（）;    
6. }    
7.    
8. //合法，声明抛出IOException异常    
9. void  method3（）抛出 IOException {    
10.   方法1（）;    
11. }    
12.    
13. //合法，声明抛出异常，IOException的是异常的子类    
14. void  method4（）抛出 Exception {    
15.   方法1（）;    
16. }    
17.    
18. //合法，捕获IOException异常    
19. void  method5（）{    
20.  尝试{    
21.     方法1（）;    
22.  } catch （IOException e）{...}    
23. }    
24.    
25. //编译错误，必须捕获或声明抛出异常    
26. void  method6（）{    
27.   尝试{    
28.     方法1（）;    
29.   } catch （IOException e）{ 抛出新的 Exception（）;}     
30. }    
31.    
32. //合法，声明抛出异常    
33. void  method7（）抛出 异常{    
34.  尝试{    
35.   方法1（）;    
36.  } catch （IOException e）{ 抛出新的 Exception（）;}     
37. }   

      判断一个方法可能会出现异常的依据如下：
     1）方法中有throw语句。例如，以上method7（）方法的catch代码块有有throw语句
     。2）调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，方法3（）方法调用了方法1（）方法，方法1（）方法声明抛出IOException异常，因此，在方法3（）方法中可能会出现IOException异常。

2.抛出异常

　  扔总是出现在函数体中，用来抛出一个Throwable的类型的异常。程序会在抛出语句后立即终止，它后面的语句执行不到，然后在包含它的所有尝试块中（可能在上层调用函数中）从里向外寻找含有与其匹配的捕获子句的试块。我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过抛出语句抛出。该语句的语法格式为：throw new exceptionname;     例如抛出一个IOException类的异常对象：    throw new IOException;     要注意的是，throw抛出的只能够是可抛出类Throwable或者其子类的实例对象。下面的操作是错误的：    抛出新的String（“exception”）;
　　
    

    这是因为String不是Throwable类的子类。

     如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

       如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是错误或RuntimeException的，则该方法的调用者可选择处理该异常。

[java]   查看纯 文本  

1. 包 测试;  
2. import  java.lang.Exception;  
3. 公共类 TestException {   
4.     static int  quotient（int  x，  int  y）  throws  MyException {  //定义方法抛出异常   
5.         if  （y <  0 ）{  //判断参数是否小于0  
6.             抛出新的 MyException（“除数不能是负数” ）; //异常信息   
7.         }  
8.         返回 x / y; //返回值  
9.     }  
10.     public static void  main（String args []）{  //主方法    
11.         int   a = 3 ;  
12.         int   b = 0 ;   
13.         尝试 {  //尝试语句包含可能发生异常的语句  
14.             int  result = quotient（a，b）; //调用方法quotient（）  
15.         }  catch  （MyException e）{  //处理自定义异常  
16.             的System.out.println（e.getMessage（））; //输出异常信息  
17.         }  catch  （ArithmeticException e）{  //处理ArithmeticException异常  
18.             System.out.println（“除数不能为0” ）; //输出提示信息  
19.         }  catch  （Exception e）{  //处理其他异常  
20.             System.out.println（“程序发生了其他的异常” ）; //输出提示信息  
21.         }  
22.     }  
23.   
24. }  
25. class  MyException  extends  Exception {  //创建自定义异常类  
26.     字符串消息; //定义String类型变量  
27.     public  MyException（String ErrorMessagr）{  //父类方法  
28.         message = ErrorMessagr;  
29.     }  
30.   
31.     public  String getMessage（）{  //覆盖getMessage（）方法  
32.         返回 消息;  
33.     }  
34. }  

4.3异常链

      1）如果调用quotient（3，-1），将发生MyException异常，程序调转到catch（MyException e）代码块中执行;

      2）如果调用商数（5,0） ，将会因“除数为0”错误引发ArithmeticException异常，属于运行时异常类，由Java的运行时系统自动抛出。商数（）方法没有捕捉ArithmeticException异常，爪哇运行时系统将沿方法调用栈查找主方法，将抛出的异常上传至quotient（）方法的调用者：

         int result = quotient（a，b）; //调用方法quotient（）
        由于该语句在try监控区域内，因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出，并匹配catch子句：

       catch（ArithmeticException e）{//处理ArithmeticException异常
的System.out.println（ “除数不能为0”）; //输出提示信息
} 

        处理结果是输出“ 除数不能为0 ”.Java这种向上传递异常信息的处理机制，形成异常链。

       Java的方法抛出的可查异常将依据调用栈，沿着方法调用的层次结构一直传递到具备处理能力的调用方法，最高层次到主要方法为止。如果异常传递到主要方法，而主要不具备处理能力，也没有通过抛出声明抛出该异常，将可能出现编译错误。

      3）如还有其他异常发生，将使用catch（Exception e）捕捉异常。由于异常是所有异常类的父类，如果将catch（Exception e）代码块放在其他两个代码块的前面，后面的代码块将永远得不到执行，就没有什么意义了，所以赶语句的顺序不可掉换。

4.4 Throwable类中的常用方法

注意：抓关键字后面括号中的异常类型的参数e.Exception就是尝试代码块传递给赶上代码块的变量类型，例如就是变量名.catch代码块中语句 “e.getMessage（）;” 用于输出错误性质通常异常处理常用3个函数来获取异常的有关信息。：

     getCause（）：返回抛出异常的原因。如果原因不存在或未知，则返回null。

　 getMeage（）：返回异常的消息信息。

　 printStackTrace（）：对象的堆栈跟踪输出到错误输出流，作为字段System.err的值。

     有时为了简单会忽略掉赶上语句后的代码，这样的try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。

 5.Java常见异常

  

在Java的中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java的虚拟机自动进行捕获处理的.java中常见的异常类：

1. runtimeException子类：

    1，java.lang.ArrayIndexOutOfBoundsException
    数组引用越界异常。当对数组的索引值为负数或大于等于数组大小时抛出
    。2，java.lang.ArithmeticException
    算术条件异常。譬如：整数除零等
    。3，java .lang.NullPointerException
    。空指针异常当应用试图在要求使用对象的地方使用了空时，抛出该异常譬如：调用空对象的实例方法，访问空对象的属性，计算空对象的长度，使用抛语句抛出空等等
    4，抛出java.lang.ClassNotFoundException
    找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的类文件时，抛出该异常。

   5，java.lang中。NegativeArraySizeException 数组长度为负异常 

   6 ，java.lang。ArrayStoreException信息 数组中包含不兼容的值抛出的异常

   7 ，java.lang。抛出：SecurityException 安全性异常

   8 ，java.lang。抛出：IllegalArgumentException 非法参数异常

2. IOException

IOException异常：操作输入流和输出流时可能出现的异常。

EOFException文件已结束异常

FileNotFoundException文件未找到异常

3.其他

ClassCastException类型转换异常类

ArrayStoreException数组中包含不兼容的值抛出的异常

SQLException操作数据库异常类

NoSuchFieldException字段未找到异常

NoSuchMethodException方法未找到抛出的异常

NumberFormatException字符串转换为数字抛出的异常

StringIndexOutOfBoundsException字符串索引超出范围抛出的异常

IllegalAccessException不允许访问某类异常

InstantiationException当应用程序试图使用Class类中的newInstance（）方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常

    

 6.自定义异常

使用Java的内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承异常类即可。
    在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过抛出关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常
（4）在出现异常方法的调用者中捕获并处理; 并处理异常。

在上面的“使用抛抛出异常”例子已经提到了。