超详细的Java异常处理机制知识整理

异常的基本概念：

异常指程序在执行过程中出现，程序本身没有预料的情况，例如读取文件，操作时文件不存在访问数据库，是驱动程序，不存在进行算数，除法运算时除数为零等情情况。

这些情况的出现，可能会导致程序出现不正确的逻辑或者导致程序结束异常，是不可避免的，出现了什么样的异常，由谁来处理异常，如何处理异常？

传统面向过程的程序语言，例如C语言，通常根据程序返回的某个特殊值或标记，并且假定接受者会检查该返回值或标记，以此来判断异常是否发生这种处理方式，会在程序的许多地方逐一查某个特定的异常并加以处理，导致正常的业务流程和异常处理代码紧密耦合，不利于代码的阅读和维护。

相比于其他语言来讲，java提供的异常处理机制具有以下优点：

1：将描述业务逻辑的代码与处理异常的代码分离，从而使代码的可读性撰写，调试和维护都大大提高。

2：把错误传播给调用堆栈

3：按错误类型和错误差别分组

3：系统提供了对于一些无法预料的错误的捕获和处理

4：克服了传统方法的错误信息有限的问题

使用异常处理的目的就是用来在发生异常时高数程序如何控制自身的运行，防止错误进一步恶化，从而导致严重的后果

Java异常的体系结构：
Throwable是所有异常和错误的父类，它主要包含了三个方面的内容：

1:线程创建时执行堆栈的快照。

2：用于描述异常或错误出现位置的消息字符串。

3：异常或错误产生的原因

Throwable有两个直接子类：Error和Exception，分别表示错误和异常，其中异常Exception又包括两大类：运行时异常(RuntimeException)和非运行时异常。

运行时异常又称为编译器不检查的异常(Unchecked Exception),非运行时异常又称为编译器检查的异常(checked Exception)

Error与Exception:

Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误，例如Out-OfMemoryError(内存溢出错误),Java虚拟机不会检查Error是否被处理，除了通知给用户并且会尽力使程序安全的终止外，程序本身是无法处理这些错误的。

Exception分为两大类：运行时异常和非运行时异常，开发人员在代码中应当尽可能去处理这些异常，从而保证程序正确执行完毕。

下表为Exception的构造方法和常用方法：

运行时的异常和非运行时的异常

各种具体的运行时异常都是RuntimeException类或者其他子类的对象，例如ClassCase-Exception(强制类型转换异常),IndexOutBoundsException(下标越界类)等，因为这类异常只有在程序运行阶段才能体现出来，所以Java编译器在编译阶段对代码是否处理了该类型异常不做检查，编译能够正确通过，该类异常一般是由程序逻辑错误引起的，因此我们在编写代码的过程中应尽可能地避免这类型的错误。

常见的运行时异常：

ArithmeticException-------->算数除法运算中除数为0

举例：

public class a {
    public static void main(String[]args){
        int a=10,b=0;
        System.out.println(a/b);
    }
}
1
2
3
4
5
6

ArrayIndexOutOfBoundsException----------->数组下标超界

举例：

public class a {
    public static void main(String[]args){
        int a[]=new int[10];
        System.out.println(a[10]);
    }
}
1
2
3
4
5
6

NumberFormatException---------->数据格式化引发的异常

public class a {
    public static void main(String[]args){
        int i=Integer.parseInt("abc");
        System.out.println(i);
    }
}
1
2
3
4
5
6

ClassCastException---------->对象类型转换不兼容

举例：

public class a {
    public static void main(String[]args){
        a a=new a();
        B b=(B)a;
    }
}
1
2
3
4
5
6

NullPointerException----------->空引用引发的异常

public class a {
    public static void main(String[]args){
        a a=new a();
        a=null;
        a.getname();
    }
    public  void getname(){
        System.out.println("我是小芳");
    }
}
1
2
3
4
5
6
7
8
9
10

常见的非运行异常：

SQLException：操作数据库时查询表可能发生的异常

IOException：操作文件时发生的异常

FileNotFoundException：操作不存在文件时发生的异常

ClassNotFoundException：加载类而类不存在时发生的异常

EOFException：操作文件到文件末尾发生异常

IllegalArguementException：参数异常
1
2
3
4
5
6
7
8
9
10
11

Java异常处理：

异常处理是指当异常发生后，程序能够转向相关的异常处理代码中并执行尝试性修复处理，再根据修复处理的结果决定程序的走向，使应用程序能够正常运行，或降级运行或安全地终止应用程序的执行，以提高应用系统的可靠性。

try/catch/finally执行情况：

try代码段：

包含在try中的代码段可能有多条语句会产生异常，但程序的一次执行过程中如果产生异常，只可能是这些异常中的某一个，该异常对象由Java运行时系统生成并抛出，try中产生异常语句，之后的语句都不会被执行，如果这次执行过程中没有产生异常，那么try中所有的语句都会被执行。

catch代码段：

捕获try中抛出的异常并在其代码段中做相应的处理，catch语句带一个Throwable类型的参数，表示可能捕获异常的类型。一般情况下，catch代码段的数量由try中所抛出的异常个数决定，当try中代码产生的异常被抛出后，catch代码段按照从上到下的书写顺序将异常类型与自己参数所指向的异常类型进行匹配，若匹配成功程序转而表示异常被捕获，程序转而执行当前catch中的代码，后面所有的catch代码段都不会被执行，如果匹配不成功，交给下一个catch进行匹配，如果所有catch都不匹配，表示当前方法不具备处理该异常的能力

对于这种情况如果是一个非运行时异常，为了编译器通过，必须使用throws关键字声明输出。

finally代码段：

该代码段不是必须有的，但是如果有一定紧跟在最后一个catch代码段后面，作为异常处理机制的统一出口（做善后处理）.

无论try中是否产生异常，finally中的代码总在当前方法返回之前无条件执行。

注意：如果在某个catch代码段中已经执行了要终止程序的System.exit()方法，那么此时finally中的代码不会执行。

throw关键字：

用来在方法体内部创建异常对象并将其抛出，如果是非运行时异常，还必须结合throws关键字在方法头部声明抛出该异常，表明当前方法没有处理该异常，将异常的处理任务延迟到当前方法的调用者，当前方法的调用者就必须检查，处理，或者继续抛出被调用方法抛出的异常

如果所有方法都层层上抛获取的异常，最终会在main方法中寻找对应的catch代码段。如果main方法中也没有对异常进行捕获，那么JVM将通过控制台打印该异常消息和堆栈信息，同时程序也会终止。

throws关键字：

用来在方法头部声明方法可能会抛出的某些异常，仅当抛出了非运行时异常，该方法的调用者才必须处理或者重新抛出该异常。

如果方法的调用者无法处理该异常，应该继续抛出而不是再catch中向控制台打印异常发生时的堆栈信息，原因是堆栈信息对于用户来说没什么实在的意义。

try {
    可能出现异常的程序代码
    
   }catch(异常类型1 异常对象名1){
   
   异常类型1对应的异常处理代码
   
} catch(异常类型2 异常对象名2){

   异常类型2对应的异常处理代码
   
} finally{
   无论是否发生异常，程序都必须执行的代码(善后代码)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

try，catch，finally关键字的使用：

这三个关键字既可以同时出现在程序中，也可以两两组合出现。

try+catch：

try{
//可能抛出异常的代码
}
catch(异常类型 异常对象名){
//针对异常的处理代码
}
1
2
3
4
5
6

举例：

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        //数组下标为0-4的元素都根据默认值正常输出了，但下标为5的元素不存在，所以便产生了数组下标越界的异常
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        //随后catch捕获到try中产生的异常，catch代码段调用异常对象的`printStackTrace()方法输出异常发生时堆栈中的信息
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        System.out.println("程序结束！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出：

0
0
0
0
0
程序结束！
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Employee.a.main(a.java:9)
1
2
3
4
5
6
7
8

通过打印出的堆栈信息，java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5at Employee.a.main(a.java:9)，我们可以看出具体错误的信息，catch代码段执行完毕后，继续执行未执行的代码。

注意：catch代码段用于处理异常，如果没有catch代码段就代表异常没有被处理，如果该异常是非运行异常，那么必须声明输出，否则编译不通过

try+finally：

try{
//可能抛出异常的代码
}
finally{
无论异常是否发生，都无条件执行的代码
}
1
2
3
4
5
6

举例：

还是上述实例，我们此时将catch换成了finally：

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        finally{
            System.out.println("我是finally代码段");
        }
        System.out.println("程序结束！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

0
0
0
0
0
我是finally代码段
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Employee.a.main(a.java:9)
1
2
3
4
5
6
7
8

对比两种组合输出的结果，看起来好像是一样的，但是仔细看，会发现try+finally这种组合，并没有执行finally下面的语句，也就是没有“程序结束”该语句的输出，原因即为try中发生了异常，但是该程序不存在catch代码段去捕获异常，所以发生异常后面的语句都不会被执行。

那么有的人会说finally中的语句为什么可以输出呢？

有这个疑问的小伙伴上去再看一下finally的用法。

try+catch+finally：

try{
//可能抛出异常的代码
}
catch(异常类型 异常对象名){
//针对异常的处理代码
}finally{
无论异常是否发生，都无条件执行的代码
}
1
2
3
4
5
6
7
8

举例：

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        finally{
            System.out.println("我是finally代码段");
        }
        System.out.println("程序结束！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出：

0
0
0
0
0
我是finally代码段
程序结束！
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Employee.a.main(a.java:9)
1
2
3
4
5
6
7
8
9

这种组合输出，当发生异常由catch捕获处理完异常之后，继续执行下面未执行完的语句。

注意！！！

1：finally代码段与其上面的catch代码段之间不能再添加其他代码语句。

2：try,finally这种形式由于没有对异常进行任何的处理，所以一般不会应用在实际开发中。

throws和throw关键字的使用：

throws关键字的使用：

如果当前方法不对异常进行处理，可以通过声明抛出异常，将处理该异常的任务交给当前方法的调用者，throws用在方法声明部分的结尾处，表示该方法抛出异常，一个方法可以声明抛出多个异常，这取决于方法中可能产生的异常个数，如果抛出多个异常，那么这些多个异常之间用逗号隔开，一个声明了抛出异常的方法定义格式如下：

[修饰符] 返回值类型 方法名([参数列表])[throws 异常列表]{
   //  方法体;
}      
1
2
3

举例：

public class a {
    public static void print() throws ArrayIndexOutOfBoundsException{
        int []arr=new int[5];
        int i;
//print()方法体并没有使用try-catch对ArrayIndexOutOfBoundsException异常进行处理，而是通过throws关键字声明抛出
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
    }
    public static void main(String[]args)throws ArrayIndexOutOfBoundsException{
    //main()方法中对print()方法进行了调用，通过try-catch方式对print()方法抛出的异常进行捕获处理。
        try{
            print();
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出：

0
0
0
0
0
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Employee.a.print(a.java:9)
	at Employee.a.main(a.java:13)
1
2
3
4
5
6
7
8

当然main方法也可以不用try-catch方式处理，而是继续通过trows关键字抛出。

那么运行结果通过运行结果，我们能够了解什么信息呢？

首先通过输出信息的最上部（异常入栈时位于栈底）入手去源文件中查找异常产生的原因。那么在本例中，我们通at Employee.a.print(a.java:9)，应该去第九行寻找原因！

注意！！！

如果一个方法通过trows声明抛出了异常，那么调用该方法的其他方法可以通过try-catch方式进行捕获处理，也可以继续通过throws声明将异常抛出。

一般不建议在main方法中通过trows声明抛出异常原因为：Java中发生异常如果一直上抛，最终抛给了main方法，main方法继续上抛，抛给了调用者JVM，JVM终止程序的执行。

这样看来好像也没什么错，但是异常处理机制的作用就是提高程序的健壮性，保证程序出现了异常也能执行，所以main方法中的异常建议是使用try-catch进行捕捉，而不是继续上抛！

throw关键字的使用：

throw关键字主要用在方法体中对异常进行抛出，通常方法体中捕获到相关异常对象后并不进行处理，将对象的处理交给当前方法的调用者，一个通过throw关键字声明抛出异常的方法定义格式如下：

[修饰符] 返回值类型 方法名([参数列表])[throws 异常列表]{
   //  方法体;
   throw异常对象；
}  
1
2
3
4

举例：

public class a { 
    public static void print(){
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        //该catch并没有对异常进行处理，而是通过trow将异常对象抛出了
        catch(ArrayIndexOutOfBoundsException e){
            throw e;
        }
    }
    public static void main(String[]args){
        try{
            print();
        }
        //main方法中的catch捕获到try中调用print方法的异常并对其进行处理
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出：

0
0
0
0
0
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Employee.a.print(a.java:8)
	at Employee.a.main(a.java:16)
1
2
3
4
5
6
7
8

提醒：
由于这里的ArrayIndexOutOfBoundsException是运行时异常，所以print()方法声明部分的结尾不再需要throws，如果throw抛出的是某个非运行异常，那么throw所在的方法的声明尾部还需要通过throws声明将这个非运行时异常对象抛出。

自定义异常：

在实际开发中，异常正所谓是“千姿百态”，但JDK提供给我们的异常类型是很有限的，因此面对实际开发中的各种异常问题，我们除了灵活使用JDK提供给我们的之外，还需要我们自定义一些异常，这些异常也就是我们在面向对象编程的过程中，出现的特有问题。

既然是自定义，那么由于每个人想法和处理问题的方式不同，很容易出现操作异常等问题，为了解决这种问题，我们规定自定义异常必须继承Exception或者RuntimeException，从Exception继承表示自定义异常是非运行时异常，从RuntimeException继承表示自定义异常是运行时异常，当腰操作自定义异常的信息时，可以使用父类已经定义好的方法

自定义异常的一般形式如下：

class 异常类名 extends Exception|RunException
{
//类体
}
1
2
3
4

举例：

当输入的分数小于0时，捕获异常并输出分数不能小于0的提示信息。

主类：

package exception;

import java.util.Scanner;

public class exception {
   public static  void show_score() throws Text {
   //该方法并没有对分数小于0的这种情况进行任何的处理，而是创建异常对象将它抛出
       int score;
       Scanner scanner=new Scanner(System.in);
       score=scanner.nextInt();
       if(score<0){
           throw new Text("分数不能小于0");
       }
   }
    public static void main(String[]args){
    //在main方法中捕获到该异常，并对其进行处理
        try{
            show_score();
        } catch (Text e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

由于JDK并没有为我们提供某一个异常来描述分数不能小于0的这种情况，所以需要自定义异常类[这里的异常类为Text类]来表示分数不能小于0的这种情况，且该异常是非运行异常，因此需要继承Exception类。

自定义异常类：

package exception;

public class Text extends Exception{
    public Text(String message) {
        super(message);
    }
}
1
2
3
4
5
6
7

输出：

注意：如果该异常属于RuntimeException，那么在方法的尾部不需要throws声明将该异常抛出，反之如果是Exception，则需要声明抛出

异常处理事项：

如果一个方法产生的异常不止一种，且这些异常具有父子关系，那么书写catch代码块时，处理异常的catch块要位于处理子异常catch块的后面。

依然是上述事例：

  public static void main(String[]args){
        try{
            show_score();
        }
        catch (Text e) {
            e.printStackTrace();
        }
        catch(Exception e){
            e.printStackTrace();
        }
1
2
3
4
5
6
7
8
9
10

由于Text异常类继承了Exception类，所以处理父类Exception类的catch代码块必须写在子类Text的后面。

在进行方法覆盖时，如果被覆盖的方法抛出异常，那么覆盖方法可以不抛异常，或者抛与被覆盖方法相同的异常，或者抛被覆盖方法的所抛异常的子异常。

定义父类抛出Exception类异常：

package exception;

public class Father {
    public void show() throws Exception{
        int a=10;
       if(a<100){
           throw new Exception();
       }
        System.out.println("hello，Java");
    }
}
1
2
3
4
5
6
7
8
9
10
11

子类对象对父类中的show方法进行覆盖：

package exception;

public class Son extends Father{
  @Override
    public void show() throws Exception {
        System.out.println("helloJava");//抛出和父类相同的异常
    }
  @Override
    public void show() throws Text{//抛出父类抛出的异常的子异常类
        System.out.println("helloJava");
    }
      @Override
    public void show() {//未抛出异常
        System.out.println("helloJava");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

以上三种方式均正确！

如果try代码中有return语句返回基本数据类型变量，即使finally中对该基本数据类型变量进行修改，返回结果以try中修改的值为准。

举例：

package exception;

import java.util.Scanner;

public class exception {
   private static int getnumber(){
       int i=0;
       try{
           i=100;
           return i;
       }catch (Exception e){
           e.printStackTrace();
       }finally//在finally中改变基本数据类型变量i的值
           i=1000;
       }
       return i;
    }
    public static void main(String[]args){
        System.out.println(getnumber());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出：

100//try中的值
1

如果try代码中有return语句，返回引用数据类型变量，finally中对该引用数据类型变量进行修改，返回结果以finally中修改的值为准。

举例：

package exception;

import java.util.Scanner;

public class exception {
    String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
private static exception getname(){
        exception exception=new exception();
        try{
            exception.setName("张三");
            return exception;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            exception.setName("小张");
        }return exception;
}

        public static void main(String[]args){
            System.out.println(getname().getName());
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

输出：

李四//finally中的值
1

如果try，finally代码中都有return语句，无论返回什么数据类型，返回结果以finally中修改的值为准。

举例：

package exception;

import java.util.Scanner;

public class exception {
    String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
private static exception getname(){
//try和finally语句中都含有return语句
        exception exception=new exception();
        try{
            exception.setName("张三");
            return exception;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            exception.setName("小张");
            return exception;
        }
}
        public static void main(String[]args){
            System.out.println(getname().getName());
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

输出：

小张//finally中的值
1