java异常处理

转自:https://blog.csdn.net/hit100410628/article/details/72876706

https://blog.csdn.net/hguisu/article/details/6155636

1.异常分类

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

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

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

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

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

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

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

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

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

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

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

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

（1）运行时异常(unchecked exception)：继承自java.lang. RuntimeException类

常见5种：

ClassCastException(类型转换异常)

IndexOutOfBoundsException(数组越界)

NullPointerException(空指针)

ArrayStoreException(数据存储异常，操作数组时类型不一致)

还有IO操作的BufferOverflowException异常

（2）非运行时异常(unchecked exception)：继承自java.lang.Exception类

常见：

Java.lang.ClassNotFoundException

Java.lang.NoSuchMetodException

java.io.IOException

2.两种异常的区别：

Checked异常必须被显式地捕获或者传递，而unchecked异常则可以不必捕获或抛出。

Checked异常继承java.lang.Exception类。Unchecked异常继承自java.lang.RuntimeException类。

3. throw，throws，try-catch的联系

（1）throw：自己手动抛出异常。或者说此处一定会出异常。

比如年龄是负的，我们需要自己手动引发异常，这就是throw的作用。

注意：

如果方法fun1()内throw抛出的是非运行时异常，则该方法必须用throws抛出，否则编译不会通过。假如fun2()调用fun1()，要将fun1()放在fun2()的try中或者fun2继续throws，否则也编译不通过。

例如：

[java]  view plain  copy

1. public void fun1(int m) throws Exception{  
2.         int age=m;  
3.         if (age<0) {  
4.             throw new Exception();  
5.         }  
6. }  

[java]  view plain  copy

1. public void fun2() {  
2.     try {  
3.         fun1(-1);             
4.     } catch (Exception e) {  
5.         System.out.println("年龄不能为负");  
6.     }  
7. }  

如果方法fun1()内throw抛出的是运行时异常，fun1既不用throws，fun2也不用try，编译也会通过。例如：

[java]  view plain  copy

1. public void fun1(int m){  
2.     int age=m;  
3.     if (age<0) {  
4.         throw new IndexOutOfBoundsException();  
5.     }  
6. }  
7. //这样编译没问题，但运行会崩溃  
8. public void fun2() {  
9.      fun1(-1);             
10. }  
11. //这样运行，不会崩溃，因为做了处理  
12. public void fun3() {  
13. try {  
14.     fun1(-1);          
15. } catch (Exception e) {  
16.     System.out.println("出异常了～");  
17. }          
18. }  

因为运行时异常产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。

（3）throws：用在方法声明后，表示方法可能会抛出异常。

如果一个方法会有异常，但你并不想处理这个异常，就在方法名后面用throws,这样这个异常就会抛出，谁调用了这个方法谁就要try- catch处理这个异常，或者继续throws抛出。

总之，用throws抛出非运行时异常的方法，调用它的方法必须try-catch或者继续throws。throws抛出的是运行时异常, 既不用throws，也不用try-catch。

例如：

[java]  view plain  copy

1. public class CheckedExceptionMethods    
2. {    
3.     // 总异常类，既有checkedException又有RuntimeException，所以其中的checkedException必须处理    
4.     public void method1() throws Exception    
5.     {    
6.         System.out.println("我是抛出异常总类的方法");    
7.     }    
8.     // 捕获并处理这个异常    
9.     public void testMethod1_01()    
10.     {    
11.         try    
12.         {    
13.             method1();    
14.         }    
15.         catch (Exception e)    
16.         {    
17.             e.printStackTrace();    
18.         }    
19.     }    
20.     // 把异常传递下去，继续抛出   
21.     public void testMethod1_02() throws Exception    
22.     {    
23.         method1();    
24.     }    
25. }  

（4）try{}catch(想要处理的异常种类){}

如果觉得方法内可能会产生异常，可以自己进行处理，调用者就不用再try-catch，例如：

[java]  view plain  copy

1. public void fun1() {  
2.     int[] a={1,2,3};  
3.     try {  
4.         System.out.println(a[3]);   
5.     } catch (Exception e) {  
6.         System.out.println("数组越界了～");  
7.     }         
8. }  
9. public void fun2() {  
10.     fun1();  
11. }  
12. 也可以偷懒不做处理，让调用者处理，例如：  
13. public static void fun1() throws Exception{  
14.     int[] a={1,2,3};  
15.         System.out.println(a[3]);            
16. }  
17. public void fun2() {  
18.     try {  
19.         fun1();       
20.     } catch (Exception e) {  
21.         System.out.println("数组越界了～");  
22.     }         
23. }