Java 之 异常的处理

Java 异常处理的五个关键字：try、catch、finally、throws、throw

一、捕获异常 try...catch

　　如果异常出现的话,会立刻终止程序,所以我们得处理异常。

　　try...catch：异常处理的第一种方式,自己处理异常

　　try...catch 的方式就是捕获异常。

　　　　捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

　　语法格式：

try{
    编写可能会出现异常的代码
    }catch(异常类型1 e){
        处理异常的代码
        //记录日志/打印异常信息/继续抛出异常
    }
    ...
    catch(异常类名2 变量名){

    }

　　   try：该代码块中编写可能产生异常的代码

　　 catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

　　注意：

　　　　（1）try和catch都不能单独使用,必须连用。

　　　　（2）try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象

　　　　（3）如果try中产生了异常,那么就会执行 catch 中的异常处理逻辑,执行完毕 catch 中的处理逻辑,继续执行try...catch之后的代码；

　　　　　　  如果 catch 无法捕获 try 中发生的异常，那么就会导致当前方法结束，并把异常对象抛出给调用者，如果调用者可以处理，那么从调用者处理代码的后面继续运行，否则继续向上抛出，最终达到 JVM；

　　　　　　  如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码

　　多个 catch 分支，如何匹配和执行的？

　　　　从上到下依次判断，一旦有一个满足了，后面就不看了。

　　　　建议：如果多个catch中的异常类型有大小包含关系，那么小的在上，大的在下，如果没有大小包含关系，顺序随意。

　　 Demo：

 1 public class TryCatchDemo {
 2     public static void main(String[] args) {
 3         try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。
 4             read("b.txt");
 5         } catch (FileNotFoundException e) {// 括号中需要定义什么呢？
 6             //try中抛出的是什么异常，在括号中就定义什么异常类型
 7             System.out.println(e);
 8         }
 9         System.out.println("over");
10     }
11      /*
12         当前的这个方法中 有异常 有编译期异常
13     */
14     public static void read(String path) throws FileNotFoundException {
15         if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
16             // 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
17             throw new FileNotFoundException("文件不存在");
18         }
19     }
20 }    

　　　扩展：Throwable类中定义了一些获取异常信息的方法（异常对象常用的方法）

public String getMessage() :获取异常的简短描述信息,原因(提示给用户的时候,就提示错误原因）
public String toString() :获取异常的类型和异常详细描述信息(不用)。
public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台，JVM打印异常对象,默认此方法,打印的异常信息是最全面的

　　Tips：包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace

　　Demo：

System.out.println(e.getMessage())；
System.out.println(e.toString());
System.out.println(e);

二、finally 代码块

　　finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

　　必须执行的代码：在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),都得在使用完之后,最终关闭打开的资源或断开连接等操作。

　　语法格式：

     try{
            可能产生异常的代码
        }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
            异常的处理逻辑,异常异常对象之后,怎么处理异常对象
            //记录日志/打印异常信息/继续抛出异常
        }
        ...
        catch(异常类名 变量名){

        }finally{
            无论是否出现异常都会执行
        }

　　注意：

　　　（1）finally不能单独使用,必须和try一起使用

　　　（2）finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)

　　Demo：

 1 public static void main(String[] args) {
 2         try {
 3             //可能会产生异常的代码
 4             readFile("c:\\a.tx");
 5         } catch (IOException e) {
 6             //异常的处理逻辑
 7             e.printStackTrace();
 8         } finally {
 9             //无论是否出现异常,都会执行
10             System.out.println("资源释放");
11         }
12     }
13
14     /*
15        如果传递的路径,不是.txt结尾
16        那么就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
17
18     */
19     public static void readFile(String fileName) throws IOException {
20
21         if(!fileName.endsWith(".txt")){
22             throw new IOException("文件的后缀名不对");
23         }
24
25         System.out.println("路径没有问题,读取文件");
26     }

　　Tips：当只有在 try 或者 catch 中调用退出 JVM 的相关方法（System.exit(0);）,此时finally才不会执行,否则finally永远会执行。

三、finally 与 return 混用

　　（1）不管try中是否发生异常，也不管catch是否可以捕获异常，也无论try或catch中是否有return。 finally中的代码都必须执行

　　（2）如果finally中有return，就从finally块的的return回去。

　　（3）如果finally中没有return，那么先把try或catch中该执行的执行完（包括把返回值的结果放到要带回调用处的操作数栈的位置），在return结束当前方法之前，先走一下finally，然后回去结束当前方法

　　结论：如果finally中没有return，finally中的代码不影响返回值。

　　Demo1：

 public static void main(String[] args) {
     String str = getNum(1);
     System.out.println(str);
 }

 public static String getNum(int a){
     try{
        System.out.println(a/0);
        if(a > 0){
             return "正数";
        }else if(a < 0){
             return "负数";
        }else{
             return "零";
         }
     }catch(Exception e){
         return "异常";
     }finally{
         return "最终";
     }
 }

　　　　运行结果：最终

　　Demo2：

 public static void main(String[] args) {
    String str = getNum(1);
    System.out.println(str);
 }

 public static String getNum(int a){
     try{
        System.out.println(a/0);
        if(a > 0){
             return "正数";
        }else if(a < 0){
             return "负数";
        }else{
             return "零";
         }
     }catch(Exception e){
         System.out.println("exception");
         return "异常";
     }finally{
         System.out.println("finally");
     }
 }

　　    运行结果：exception

　　　　　　　  finally

　　　　　　　  异常

　　Demo3：

 　　public static void main(String[] args) {
         int num = getNum(4);
         System.out.println(num);//
     }

     public static int getNum(int a){
         int result = 10;
         try{
             System.out.println(a/0);
             if(a > 0){
                 result = 20;
                 return result;
             }else if(a < 0){
                 result = -20;
                 return result;
             }else{
                 return result;
             }
         }catch(Exception e){
             System.out.println("exception");
             result = 0;
             return result;     //从这里返回，result=0
         }finally{
             result = 30;
             System.out.println("finally");
 //            return result;//如果有这句，结果就变成30
         }
     }

　　　　运行结果：exception

　　　　　　　　　finally

　　　　　　　　　0

　　Demo4：

 public class Test {
     {
         System.out.println("b");
     }
     static{
         System.out.println("a");
     }
     TestExer4(){
         System.out.println("c");
     }
     public static String getOut(){
         try{
             return "1";
         }catch(Exception e){
             return "2";
         }finally{
             return "3";
         }
     }
     public static void main(String[] args) {
         System.out.println(getOut());//
     }
 }

　　　　运行结果：a

　　　　　　　　　3

四、抛出异常 throws

　　声明异常：将问题标识出来，报告给调用者。如果方法内通过 throw 抛出了编译时异常，而没有捕获处理，那么必须通过 throws 进行声明，让调用者去处理。

　　throws 关键字：异常处理的第二种方式，在当前方法中不处理，抛给调用者处理。

　　作用：

　　　　当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象。

　　　　可以使用 throws 关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理

　　声明异常格式：

 修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{
            throw new AAAExcepiton("产生原因");
            throw new BBBExcepiton("产生原因");
            ...
 }

　　　　注意：

　　　　（1）throws 关键字必须写在方法声明处

　　　　（2）throws 关键字后边声明的异常必须是 Exception 或者是 Exception 的子类

　　　　（3）方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常，如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可

　　　　（4）调用了一个声明抛出异常的方法,我们就必须的处理声明的异常：

　　　　　　　① 要么继续使用 throws 声明抛出,交给方法的调用者处理,最终交给JVM

　　　　　　　② 要么 try...catch 自己处理异常

　　　Demo：

 1 public class ThrowsDemo {
 2     public static void main(String[] args) throws IOException {
 3         read("c:\\a.tx");
 4     }
 5    public static void readFile(String fileName) throws FileNotFoundException,IOException{
 6         if(!fileName.equals("c:\\a.txt")){
 7             throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
 8         }
 9
10         /*
11             如果传递的路径,不是.txt结尾
12             那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
13
14          */
15         if(!fileName.endsWith(".txt")){
16             throw new IOException("文件的后缀名不对");
17         }
18
19         System.out.println("路径没有问题,读取文件");
20     }
21 }

　　注意：

　　　　（1）FileNotFoundException extends IOException extends Excepiton， 如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可

　　　　（2）FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常，可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理。

五、声明手动抛出异常 throw

　　在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者 。

　　在java中，提供了一个 throw 关键字，它用来抛出一个指定的异常对象。 在当前方法中不处理，抛给调用者处理。

　　异常的对象的创建和抛出有两种方式：

　　　　（1）JVM 创建并抛出

　　　　（2）手动 new 出来，然后由 throw 抛出。

　　Throwable：

　　　　只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。

　　　　类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

　　实现步骤：

　　　　1、创建一个异常对象。封装一些提示信息（信息可以自己编写）

　　　　2、需要将这个异常对象告诉给调用者。通过关键字 throw 就可以完成。throw 异常对象。

　　throw 关键字作用：用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
　　使用格式：

throw new 异常类名("异常产生的原因");

　　注意：

　　　（1）throw 关键字必须写在方法的内部

　　　（2）throw 关键字后边new的对象必须是Exception或者Exception的子类对象

　　　（3）throw 关键字抛出指定的异常对象,我们就必须处理这个异常对象

　　　　　　throw 关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
　　　　　　throw 关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch

　　

　　面试题：throw 与 throws 有什么区别？

　　　　　　（1）throw用于手动抛出异常对象，是个可执行的语句

　　　　　　（2）throws，在方法签名中，声明方法可能抛出什么异常，让调用者来处理这些异常。

　　Demo：

 // 主方法
  public static void main(String[] args) {
         //int[] arr = null;
         int[] arr = new int[3];
         int e = getElement(arr,3);
         System.out.println(e);
  }
 // 定义一个方法，获取数组指定索引处的元素
 public static int getElement(int[] arr,int index){
         /*
             我们可以对传递过来的参数数组,进行合法性校验
             如果数组arr的值是null
             那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
          */
         if(arr == null){
             throw new NullPointerException("传递的数组的值是null");
         }

         /*
             我们可以对传递过来的参数index进行合法性校验
             如果index的范围不在数组的索引范围内
             那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
          */
         if(index<0 || index>arr.length-1){
             /*
 　　　　　　　　判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。
 　　　　　　　　这时就会结束当前方法的执行，并将异常告知给调用者。这时就需要通过异常来解决。
 　　　　　　　　*/
             throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
         }

         int ele = arr[index];
         return ele;
     }
     

　　　　注意：NullPointerException、ArrayIndexOutOfBoundsException 是一个运行期异常,我们不用处理,默认交给JVM处理。

　　　　Tips：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。 对于调用者，有两种解决方式：一种是进行捕获处理，另一种就是继续将异常声明出去，使用 throws 声明处理。

　　　　扩展：Objects 非空判断

　　　　　　Objects 是由一些静态的使用方法组成，这些方法是 null-save（空指针安全的）或 null-tolerant（容忍空指针的），那么在它的源码中，对对象的null 值进行了抛出异常操作。

public static <T> T requireNonNull(T obj) :查看指定引用对象不是null。

　　　　源码：

 public static <T> T requireNonNull(T obj) {
      if (obj == null)
           throw new NullPointerException();
        return obj;
  }

　　  这样，当我们需要对传递过来的参数进行合法判断，判断是否为 null的时候，可以直接使用 该方法即可。

　　Demo：

 public static void method(Object obj){
         //对传递过来的参数进行合法性判断,判断是否为null
         /*if(obj == null){
             throw new NullPointerException("传递的对象的值是null");
         }*/

         //Objects.requireNonNull(obj);
         Objects.requireNonNull(obj,"传递的对象的值是null");   // 方法重载
 }

五、异常注意事项

　　1、多个异常使用捕获如何处理

　　　　 ① 多个异常分别处理。

　　　　　　即每一个异常都使用一个 try-catch 捕获，然后进行处理。

　　　　② 多个异常一次捕获，多次处理。

　　　　　　即把异常都放入 try 里面，而 catch 里面处理写每一个异常的情况。

　　　　③ 多个异常一次捕获一次处理。

　　　　　　即把异常都放入 try 里面，而 catch 里面放入 所有异常的一个父类，来进行统一处理。

　　　　经常使用 一次捕获多次处理 方式，格式如下：

try{
    编写可能会出现异常的代码
    }catch(异常类型A e){ 当try中出现A类型异常,就用该catch来捕获.
        处理异常的代码
        //记录日志/打印异常信息/继续抛出异常
    }catch(异常类型B e){ 当try中出现B类型异常,就用该catch来捕获.
        处理异常的代码
        //记录日志/打印异常信息/继续抛出异常
}

　　　　注意：这种异常处理方式，要求多个 catch 中的异常不能相同，并且若 catch 中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的 catch 处理，父类异常在下面的 catch 处理。

　　2、运行时异常被抛出可以不处理。即不捕获也不声明抛出

　　　　运行时异常被抛出可以不处理，因为最后默认给虚拟机处理，会终止程序，什么时候不抛出运行时异常了,在来继续执行程序

　　3、如果 finally 有 return 语句，永远返回 finally 中的结果，避免该情况。

　　　　原因：因为 finally 中的语句都会被执行到，所以 finally 里面有 return，永远返回 finally 中的结果。

　　4、如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

　　5、父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。