Java基础学习总结（22）——异常处理

不念不忘少年蓝@ 2022-10-02 07:49 240阅读 0赞

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、异常的概念

　　异常指的是运行期出现的错误，也就是当程序开始执行以后执行期出现的错误。出现错误时观察错误的名字和行号最为重要。

　　

复制代码

  1. 1 package cn.javastudy.summary;
  2.  2 
  3.  3 public class TestEx{
  4.  4     
  5.  5     public static void main(String args[]){
  6.  6         int arr[]={1,2,3};
  7.  7         System.out.println(arr[2]);
  8.  8         /**
  9.  9          * 这里使用try……catch来捕获除以0产生的异常，其基本格式是：
  10. 10          * try{
  11. 11                 statements;//可能产生异常的语句
  12. 12                 ……
  13. 13             }
  14. 14             catch(Throwable-subclass e){//异常参数e
  15. 15                 statements;//异常处理程序
  16. 16                 ……
  17. 17             }
  18. 18          */
  19. 19         try{
  20. 20             System.out.println(arr[2]/0);
  21. 21         }catch(ArithmeticException ae){
  22.      //这里是这个异常参数的类型声明，即声明这个异常是属于哪种类型的异常
  23. 22             System.out.println("系统正在维护中，请稍后！");
  24. 23             /**
  25. 24              * 这里使用printStackTrace()方法把这个错误的堆栈信息打印出来。
  26. 25              * 所谓的“错误堆栈信息”指的是这个错误有可能是上一个错误引起的，
  27. 26              * 而上一个错误又有可能是由另外一个错误引起的。到底是由哪个错误引起的，
  28. 27              * 把所有的错误信息全都打印出来就知道了。这种信息往往能给我们程序员调试错误的提示。
  29. 28              * 这些信息很有用，因此我们往往使用这个方法把错误信息打印出来。
  30. 29              * 默认打印错误提示信息采用的也是使用这种方法打印出来的
  31. 30              */
  32. 31             ae.printStackTrace();
  33. 32         }
  34. 33     }
  35. 34 }

复制代码

代码运行结果：

　　

小结：

　　异常是运行期间出现的错误，运行期间出现错误以后JAVA处理这种错误的方式是首先会找相应的catch代码，看看有没有使用catch去捕获异常，如果有catch存在，那么JAVA就会自动跳到catch那里去处理异常，如果没有catch，那么JAVA将会把这个错误抛出去，然后将相关的错误信息打印出来。想用catch捕获异常时必须要写try，没有try就不能用catch，try里面写的是有可能产生异常的语句，catch里面写的是当try里面的语句运行时出现了异常的处理方式。

　　方法声明的时候可以指明这个方法有可能会抛出的异常类型，使用throw抛出异常，声明方法后面有throws声明的可能出现的异常一定要去捕获。

　　

二、异常的分类

　　

三、异常的捕获和处理

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

　　

　　

　　

　　

　　当捕获到异常以后一定要做出处理，哪怕是把这个异常的错误信息打印出来，这是一种良好的编程习惯。如果不处理，那就是把这个错误悄悄地隐藏起来了，可是这个错误依然是存在的，只不过看不到了而已。这是一种非常危险的编程习惯，绝对不能这样做，捕获到异常就一定要做出处理，实在处理不了就把异常抛出去，让别的方法去处理。总之就是不能捕获到异常之后却又不做出相应的处理，这是一种非常不好的编程习惯。

　　任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。除了在做测试以外，在实际当中编程的时候，在main方法里抛Exception是一个非常不好的编程习惯，应该使用try……catch去捕获异常并处理掉捕获后的异常。不能直接在main方法里把Exception抛出去交给JAVA运行时系统出力就完事了，这是一种不负责任的表现。如果想把程序写得特别健壮，使用try……catch去捕获异常并处理掉捕获后的异常是必不可少的做法。

四、try…cath…finally语句

　　4.1. try语句

　　

　　4.2. catch语句

　　

　　我们一般使用printStackTrace()这个方法来打印异常的信息，使用这个方法打印出来的是所有出错的信息，包括了使用getMessage()方法打印出来的信息。使用这个方法之前要new一个错误对象出来才能调用它。因为它是专属于某个错误对象里面的方法。

　　4.3. finally语句

　　

　　4.4.异常简单测试

复制代码

  1. 1 package cn.javastudy.summary;
  2.   2 
  3.   3 import java.io.FileInputStream;
  4.   4 import java.io.FileNotFoundException;
  5.   5 import java.io.IOException;
  6.   6 
  7.   7 public class TestException {
  8.   8     
  9.   9     /**
  10.  10      * 任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，
  11.  11      * 因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。
  12.  12      * 使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，
  13.  13      * 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
  14.  14      * @throws Exception
  15.  15      */
  16.  16     void fn() throws Exception {
  17.  17         
  18.  18     }
  19.  19     
  20.  20     /**
  21.  21      * 在知道异常的类型以后，方法声明时使用throws把异常往外抛
  22.  22      * @param i
  23.  23      * @throws ArithmeticException
  24.  24      */
  25.  25     void m1(int i)  throws ArithmeticException {
  26.  26         
  27.  27     }
  28.  28     
  29.  29     void m2(int i) {
  30.  30         if (i == 0) {
  31.  31             //这种做法就是手动抛出异常，使用“throw+new出来的异常对象”就可以把这个异常对象抛出去了。
  32.  32             //这里是new了一个异常对象，在构建这个对象的时候还可以指定他相关的信息，如这里指明了异常信息“i不能等于0”
  33.  33             //这个对象抛出去的时候使用getMessage()方法拿到的就是“i不能等于0”这种信息。
  34.  34             throw new ArithmeticException("i不能等于0");
  35.  35         }
  36.  36     }
  37.  37     
  38.  38     /**
  39.  39      * 正常情况下如果这里不写try……catch语句那么程序编译时一定会报错，
  40.  40      * 因为这里有可能会产生两个个必须要处理的异常：FileNotFoundException和IOException。
  41.  41      * 但由于在声明方法f()时已经使用throws把可能产生的这两个异常抛出了，
  42.  42      * 所以这里可以不写try……catch语句去处理可能会产生的异常。
  43.  43      * f()方法把抛出的异常交给下一个要调用它的方法去处理
  44.  44      * @throws FileNotFoundException
  45.  45      * @throws IOException
  46.  46      */
  47.  47     void f() throws FileNotFoundException, IOException {
  48.  48         //这里有可能会产生FileNotFoundException异常
  49.  49         FileInputStream fis = new FileInputStream("MyFile.txt");
  50.  50         //这里有可能会产生IOException异常
  51.  51         int b = fis.read();
  52.  52         while (b != -1) {
  53.  53             System.out.println((char)b);
  54.  54             b = fis.read();
  55.  55         }
  56.  56     }
  57.  57     
  58.  58     /**
  59.  59      * 在f2()方法里面调用f()方法时必须要处理f()方法抛出来的异常，
  60.  60      * 当然，如果f2()方法也没有办法处理f()方法抛出来的异常，那么f2()方法也可以使用throws把异常抛出，
  61.  61      * 交给下一个调用了f2()的方法去处理f()方法抛出来的异常。
  62.  62      * 这里f2()调用f()方法时，选择不处理f()方法中可能抛出的异常，将异常继续抛出
  63.  63      * @throws Exception
  64.  64      */
  65.  65     void f2() throws Exception {
  66.  66         f();
  67.  67     }
  68.  68     
  69.  69     /**
  70.  70      * f3方法调用f方法捕获f()方法抛出的2个异常并进行处理
  71.  71      */
  72.  72     void f3() {
  73.  73         try {
  74.  74             f();
  75.  75         } catch (FileNotFoundException e) {
  76.  76             System.out.println(e.getMessage());//处理的方法是把错误信息打印出来
  77.  77         } catch (IOException e) {
  78.  78             e.printStackTrace();//处理的方法是使用printStackTrace()方法把错误的堆栈信息全部打印出来。
  79.  79         }
  80.  80     }
  81.  81     
  82.  82     public static void main(String[] args) {
  83.  83         FileInputStream fis = null;
  84.  84         try {
  85.  85             fis = new FileInputStream("MyFile.txt");
  86.  86             int b = fis.read();//这个有可能会抛出IOException异常
  87.  87             while (b != -1) {
  88.  88                 System.out.println((char)b);
  89.  89                 b = fis.read();
  90.  90             }
  91.  91         } catch (FileNotFoundException e) {
  92.  92             //使用catch捕获FileNotFoundException类异常的异常对象e。并让异常对象e自己调用printStackTrace方法打印出全部的错误信息
  93.  93             e.printStackTrace();
  94.  94         } catch (IOException e) {
  95.  95             //再次使用catch捕获IOException类的异常对象e，并让异常对象e自己调用getMessage()方法将错误信息打印出来。
  96.  96             System.out.println(e.getMessage());;
  97.  97         }finally{
  98.  98             try {
  99.  99                 /**
  100. 100                  * 前面已经把一个文件打开了，不管打开这个文件时有没有错误发生，即有没有产生异常，最后都一定要把这个文件关闭掉，
  101. 101                  * 因此使用了finally语句，在finally语句里面不管前面这个文件打开时是否产生异常，在finally这里执行in.close()都能把这个文件关闭掉，
  102. 102                  * 关闭文件也有可能会产生异常，因此在finally里面也使用了try……catch语句去捕获有可能产生的异常。
  103. 103                  */
  104. 104                 fis.close();
  105. 105             } catch (IOException e) {
  106. 106                 e.printStackTrace();
  107. 107             }
  108. 108         }
  109. 109     }
  110. 110 }

复制代码

五、声明并抛出异常

六、使用自定义异常

　　

6.1. 自定义异常

复制代码

  1. 1 package cn.javastudy.summary;
  2.  2 
  3.  3 /**
  4.  4  * 自定义的一个异常类MyException，且是从Exception类继承而来
  5.  5  */
  6.  6 public class MyException extends Exception {
  7.  7 
  8.  8     private int id;
  9.  9 
  10. 10     /**
  11. 11      * 自定义异常类的构造方法
  12. 12      * @param message
  13. 13      * @param id
  14. 14      */
  15. 15     public MyException(String message,int id) {
  16. 16         super(message);//调用父类Exception的构造方法
  17. 17         this.id = id;
  18. 18     }
  19. 19     
  20. 20     /**
  21. 21      * 获取异常的代码
  22. 22      * @return
  23. 23      */
  24. 24     public int getId() {
  25. 25         return id;
  26. 26     }
  27. 27     
  28. 28 }

复制代码

6.2.自定义异常测试

复制代码

  1. 1 package cn.javastudy.summary;
  2.  2 
  3.  3 import java.text.MessageFormat;
  4.  4 
  5.  5 public class TestMyException {
  6.  6 
  7.  7     //throws MyException,抛出我们自定义的MyException类的异常。
  8.  8     public void regist(int num) throws MyException {
  9.  9         if (num < 0) {
  10. 10             //使用throw手动抛出一个MyException类的异常对象。
  11. 11             throw new MyException("人数为负值，不合理", 1);
  12. 12         }
  13. 13         /**
  14. 14          * 注意：当我们抛出了异常之后，
  15. 15          * System.out.println(MessageFormat.format("登记人数：{0}",num));是不会被执行的。
  16. 16          * 抛出异常之后整个方法的调用就结束了。
  17. 17          */
  18. 18         System.out.println(MessageFormat.format("登记人数：{0}",num));
  19. 19     }
  20. 20     
  21. 21     public void manage() {
  22. 22         try {
  23. 23             regist(-100);
  24. 24         } catch (MyException e) {
  25. 25             System.out.println("登记失败，错误码："+e.getId());
  26. 26             e.printStackTrace();
  27. 27         }
  28. 28         System.out.println("操作结束");
  29. 29     }
  30. 30     
  31. 31     
  32. 32     public static void main(String[] args) {
  33. 33         TestMyException t = new TestMyException();
  34. 34         t.manage();
  35. 35     }
  36. 36 
  37. 37 }

复制代码

测试结果：

　　

七、异常处理总结

　　

　　养成良好的编程习惯，不要把错误给吞噬掉（即捕获到异常以后又不做出相应处理的做法，这种做法相当于是把错误隐藏起来了，可实际上错误依然还是存在的）， 也不要轻易地往外抛错误，能处理的一定要处理，不能处理的一定要往外抛。往外抛的方法有两种，一种是在知道异常的类型以后，方法声明时使用throws把 异常往外抛，另一种是手动往外抛，使用“throw+异常对象”你相当于是把这个异常对象抛出去了，然后在方法的声明写上要抛的那种异常。

转载于:https://my.oschina.net/zhanghaiyang/blog/594276

发表评论

表情：
评论列表 （有 0 条评论，240人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java异常处理总结

                背景               ![format_png][] 最近专门负责团队的项目质量。我在治理异常日志过程中，总结了一下Java的异常处理。

    冷不防冷不防/ 0 赞/ 81 阅读