1.异常

1.1异常定义

异常：就是程序运行中出现的不正常的
java中将这些已经遇见到的不正确的情况，封装成了类，这种类叫做异常类

1.2生成异常和处理

生成异常：
当满足了异常条件的时候会执行以下操作：

  1. 1.创建异常对象
  1. 2.抛出异常对象
  1. 执行这两个功能后，叫做产生了异常，这个过程是java自动做得（java异常处理机制），我们见不到

处理：

  • 1.捕获异常

  • 2.声明抛出异常

    1.3处理机制

    java中设计的异常以及错误的类有一个完整地庞大的处理机制

  • 异常和错误的类有以下结构：

  • Throwable—异常和错误的顶级父类
  • 有两个子类：Error，代码无法处理的错误，比如停电，服务器宕机等
    1.      Exception，通过代码的调试可以处理的异常
    1.      这个EXception有很多的子类--IOException，FileNotFoundException··········

    1.4案例

    ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-03-9:21 */

import java.io.FileWriter; import java.io.IOException; import java.util.Scanner;

public class Exception { public static void main(String[] args) throws IOException { Scanner sc=new Scanner(System.in); System.out.println(“文件路径：”); String path=sc.next();

  1.     //创建文件流
  2.     FileWriter fw=new FileWriter(path);
  4.     //写出内容
  5.     fw.write("王嘉尔");
  7.     //关闭资源
  8.     fw.close();
  9. }

}

  1. **注意！！！**<br />**![image.png](https://cdn.nlark.com/yuque/0/2020/png/2706946/1606960425503-2d459774-28bc-43bf-90ea-d1acfea62673.png#align=left&display=inline&height=106&margin=%5Bobject%20Object%5D&name=image.png&originHeight=211&originWidth=1479&size=49554&status=done&style=none&width=739.5)**
  2. <a name="06eyQ"></a>
  3. ### 1.5演示运行时异常的情况
  4. **注意**<br />**     将异常抛出去的时候，不能抛给main方法，因为处理异常的时候谁调用这个有异常的方法，谁就来处理这个异常，main方法是由jvm，所以不能让jvm来处理异常，所以我们通常在开发中，main方法中直接处理掉![image.png](https://cdn.nlark.com/yuque/0/2020/png/2706946/1606960002865-d2a157db-d2ad-4dfe-91b1-0f8ca2fee2f5.png#align=left&display=inline&height=193&margin=%5Bobject%20Object%5D&name=image.png&originHeight=386&originWidth=902&size=248954&status=done&style=none&width=451)**
  5. <a name="QOyp5"></a>
  6. ### 1.6try/catch（捕获异常处理）
  8. - 将异常捕获，使用try/catch做一个分支处理--如果存在异常就抓取并且处理，
  9. - 如果没有异常就直接往下执行
  10. - <br />
  11. - 格式：
  12. - try{

//需要检测异常的代码

  1. }catch(异常类名 异常变量){

//异常处理的代码

  1. ```
  2. 可以调用异常的方法
  1. 通常我们只使用一个方法--printStackTrace(打印异常信息)

}

  1. public class TruCatchDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         //使用try/catch处理异常
  4.         Scanner sc=new Scanner(System.in);
  5.         System.out.println("请输入文件路径：");
  6.         String path=sc.next();
  8.         //抓取异常处理
  9.         try {
  10.             //可能出现异常的代码
  11.             FileWriter fw=new FileWriter(path);
  12.             System.out.println("输出成功");
  13.         }catch (IOException ie){
  14.             //打印异常信息
  15.             ie.printStackTrace();
  16.         }
  17.         System.out.println("没有抓取到异常，继续后面的程序");
  18.     }
  19. }

image.png

1.7 Throws（声明抛出异常）

在某个方法声明上，让它（方法）抛出产生的异常，自己不需要处理的，谁调用这个方法，谁就处理这个异常

  • 语法：方法的声明上加上throws 异常类名

  • 比如：
  • 方法a中产生了异常，声明抛出
  • 方法b调用了了方法a，则该异常从a转到了b，并且由b处理异常

  • 注意：
  • 一般情况下main方法中不能抛出异常，因为main方法的上一级是jvm，jvm的处理方式就是终止程序，
  • 这样的处理没有意义，所以main要自己处理

image.png
image.png

1.8 运行时异常

就是在运行期间出现的异常，通常在编译期是不会报错的

  • 处理方式：
  • 可以处理，也可以不出来——按照需求而定

  • 一般情况下，遇到java自身提供的运行时异常，都可以通过逻辑处理来解决，避免异常产生
  • 常见的运行时异常：空指针异常，数组下标越界异常，类造型异常等·········

  • 处理方式：
  • 声明抛出异常

  • 捕获处理

    1.9多异常处理

    多异常处理方式：

  • 1.声明抛出异常，直接抛出多个异常

  • 2.一个try多个catch的方式

  • 异常处理中，java实际上是中断异常的处理方式

这个案例也是一个反面教材：

  • 在处理多个异常的时候，可以直接利用异常的父类Exception直接处理子类异常，这个做法在语法上没有问题，但是逻辑中不能这么用，一旦直接使用父类处理异常，就没有办法再去处理子类异常。

image.png

1.10异常在继承中的使用和注意事项：

子类在重写父类的方法的时候，子类的方法必须抛出相同的异常或者是父类异常的子类

  • 记住：子类重写父类中的方法的时候，异常的抛出必须小于等于父类的方法抛出的异常

    1.11catch多个异常时注意的事项：

    在捕获的时候可以使用父类的异常引用指向子类的异常对象，是多态体现（向上造型）

  • 当多异常处理的时候，捕获异常，前面的异常类不能是后面的异常类的父类—也就是在多异常catch的时候

  • 遵循从小到大的原则—先捕获子类异常再捕获父类异常

  • 在处理异常的时候，catch会根据运行的过程先从子类异常开始处理，如果子类异常无法处理，
  • 则最后给父类异常处理

  • 所有异常的父类是：Exception

    1.12继承关系下异常的处理以及注意事项

    1.如果父类的方法抛出了多个异常，子类重写的时候，只能抛出相同的异常或者是他的子类异常，

  • 子类不能抛出父类中没有的异常（可以理解为自定义）！！！—-异常类中

2.如果父类中被被重写的方法没有抛出异常，子类中的方法绝对不可以抛出异常

  • 如果子类中的方法发生了异常，只能通过try/catch自行处理！不能throws

  • 在实际开发中，一般父类的方法和子类的重写的方法异常是一样的，不存在不一样的情况！！

    1.13finally代码块的案例

    在try/catch后面追加的finally代码块，其中的代码一定会被执行，通常用于资源的关闭等等操作—

  • 有需要子处理完异常后必定执行的代码放在finally代码块中


  • 使用非常的单一：就是放在异常处理结构的最后

案例

  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-03-15:11
  6.  */
  8. import java.io.FileWriter;
  9. import java.io.IOException;
  10. import java.util.Scanner;
  12. /**
  13.  * finally代码块的案例
  14.  *
  15.  * 在try/catch后面追加的finally代码块，其中的代码一定会被执行，通常用于资源的关闭等等操作--
  16.  * 有需要子处理完异常后必定执行的代码放在finally代码块中
  17.  *
  18.  * 使用非常的单一：就是放在异常处理结构的最后
  19.  */
  20. public class FinallyDemo {
  21.     public static void main(String[] args) {
  22.         Scanner sc=new Scanner(System.in);
  23.         System.out.println("请输入路径：");
  24.         String path=sc.next();
  26.         //开发过程中的常规写法--规范性
  27.         FileWriter fw=null;
  28.         try {
  29.             fw=new FileWriter(path);
  30.             fw.write("周杰伦");
  31.             return;//结束方法，最后会执行finally
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.             System.out.println("产生了IO问题");
  35.         }finally {//追加finally
  36.                 //最终进行关闭
  37.                 System.out.println("关闭资源");
  38.                 //非空判断--目的是保证当前的fw文件流中是空的（即没有fw这个对象）--是空的就是关闭状态
  39.                 if(fw != null){
  40.                     try {
  41.                         fw.close();
  42.                     }catch (IOException io){
  43.                         io.printStackTrace();
  44.                     }
  45.                 }
  46.         }
  47.         System.out.println("执行");
  48.     }
  49. }

1.14演示finally的注意点

  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-03-15:24
  6.  */
  8. import java.io.FileWriter;
  9. import java.io.IOException;
  11. /**
  12.  * 演示finally的注意点
  13.  */
  14. public class FinallyTest {
  15.     public static void main(String[] args) {
  16.         try {
  17.             System.out.println(10/0);
  18.             FileWriter fw=new FileWriter("");
  19.         }catch (ArithmeticException ae){
  20.             System.out.println("算法异常");
  21.         }catch (IOException ie){
  22.             System.out.println("文件异常");
  23.         }finally {
  24.             //注意：在finally中通常不写return，因为finally是必须会执行的，会将上面的代码的返回值覆盖
  25.             return;
  26.         }
  27. //        System.out.println("执行后面代码");
  28.     }
  29. }

1.5演示finally的案例

  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-03-15:32
  6.  */
  8. import javafx.concurrent.Worker;
  10. /**
  11.  * 演示finally的案例
  12.  *
  13.  * 注意：
  14.  * 在finally中的return是在方法执行结束之后会再次执行finally中的return代码，
  15.  * 所以会将上面的所有的return的结果全部覆盖
  16.  */
  17. public class FinallyTest2 {
  18.     public static void main(String[] args) {
  19.         System.out.println(work());
  20.     }
  21.     public static int work(){
  22.         int x=3;
  23.         try {
  24.             return x;
  25.         }catch (Exception e){
  26.             e.printStackTrace();
  27.         }finally {
  28.             x=5;
  29.             return x;
  30.         }
  31.     }
  32. }