zoukankan      html  css  js  c++  java
  • Java 之 异常的处理

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

    一、捕获异常 try...catch

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

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

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

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

      语法格式 

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

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

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

      注意

        (1)trycatch都不能单独使用,必须连用。 

        (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:

     1 public static void main(String[] args) {
     2     String str = getNum(1);
     3     System.out.println(str);
     4 }
     5     
     6 public static String getNum(int a){
     7     try{
     8        System.out.println(a/0);
     9        if(a > 0){
    10             return "正数";
    11        }else if(a < 0){
    12             return "负数";
    13        }else{
    14             return "零";
    15         }
    16     }catch(Exception e){
    17         return "异常";
    18     }finally{
    19         return "最终";
    20     }
    21 }

        运行结果:最终

      Demo2:

     1 public static void main(String[] args) {
     2    String str = getNum(1);
     3    System.out.println(str);
     4 }
     5     
     6 public static String getNum(int a){
     7     try{
     8        System.out.println(a/0);
     9        if(a > 0){
    10             return "正数";
    11        }else if(a < 0){
    12             return "负数";
    13        }else{
    14             return "零";
    15         }
    16     }catch(Exception e){
    17         System.out.println("exception");
    18         return "异常";
    19     }finally{
    20         System.out.println("finally");
    21     }
    22 }

          运行结果:exception

             finally

             异常

      Demo3:

     1   public static void main(String[] args) {
     2         int num = getNum(4);
     3         System.out.println(num);//0
     4     }
     5     
     6     public static int getNum(int a){
     7         int result = 10;
     8         try{
     9             System.out.println(a/0);
    10             if(a > 0){
    11                 result = 20;
    12                 return result;
    13             }else if(a < 0){
    14                 result = -20;
    15                 return result;
    16             }else{
    17                 return result;
    18             }
    19         }catch(Exception e){
    20             System.out.println("exception");
    21             result = 0;
    22             return result;     //从这里返回,result=0
    23         }finally{
    24             result = 30;
    25             System.out.println("finally");
    26 //            return result;//如果有这句,结果就变成30
    27         }
    28     }

        运行结果:exception

             finally

             0

      Demo4:

     1 public class Test {
     2     {
     3         System.out.println("b");
     4     }
     5     static{
     6         System.out.println("a");
     7     }
     8     TestExer4(){
     9         System.out.println("c");
    10     }
    11     public static String getOut(){
    12         try{
    13             return "1";
    14         }catch(Exception e){
    15             return "2";
    16         }finally{
    17             return "3";
    18         }
    19     }
    20     public static void main(String[] args) {
    21         System.out.println(getOut());//3
    22     }
    23 }

        运行结果: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:

     1 // 主方法
     2  public static void main(String[] args) {
     3         //int[] arr = null;
     4         int[] arr = new int[3];
     5         int e = getElement(arr,3);
     6         System.out.println(e);
     7  }
     8 // 定义一个方法,获取数组指定索引处的元素
     9 public static int getElement(int[] arr,int index){
    10         /*
    11             我们可以对传递过来的参数数组,进行合法性校验
    12             如果数组arr的值是null
    13             那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
    14          */
    15         if(arr == null){
    16             throw new NullPointerException("传递的数组的值是null");
    17         }
    18 
    19         /*
    20             我们可以对传递过来的参数index进行合法性校验
    21             如果index的范围不在数组的索引范围内
    22             那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
    23          */
    24         if(index<0 || index>arr.length-1){
    25             /*
    26         判断条件如果满足,当执行完throw抛出异常对象后,方法已经无法继续运算。
    27         这时就会结束当前方法的执行,并将异常告知给调用者。这时就需要通过异常来解决。
    28         */
    29             throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
    30         }
    31 
    32         int ele = arr[index];
    33         return ele;
    34     }
    35     

        注意: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:

    1 public static void method(Object obj){
    2         //对传递过来的参数进行合法性判断,判断是否为null
    3         /*if(obj == null){
    4             throw new NullPointerException("传递的对象的值是null");
    5         }*/
    6 
    7         //Objects.requireNonNull(obj);
    8         Objects.requireNonNull(obj,"传递的对象的值是null");   // 方法重载
    9 }

    五、异常注意事项

      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、父类方法没有抛出异常,子类重写父类该方法时也不可抛出异常。此时子类产生该异常,只能捕获处理,不能声明抛出。

      

  • 相关阅读:
    HyperV应用指南之4虚拟机管理[转]
    Windows Server 2003文件夹不能共享的解决办法【转】
    彻底了解DVD:从入门到精通(二)[转]
    HyperV应用指南之2--安装HyperV Server 2008 R2并配置远程管理[转]
    HyperV应用指南之HyperV应用基础[转]
    IIS7.5由于权限不足而无法读取配置文件的解决办法
    C# 十六进制字符串与数值类型之间转换(转)
    分享一个Winform下的分页控件[转]
    mysql的replace函数替换字符串功能简介
    聊聊.net程序设计——浅谈使用VS2010建模拓展(下)[转]
  • 原文地址:https://www.cnblogs.com/niujifei/p/11449600.html
Copyright © 2011-2022 走看看