前言

不同的编程语言都需要有程序执行失败，发生报错后的处理机制。在Java语言设计之初，就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个异常类来表示，不同类型的异常对应不同的子类异常（目前我们所说的异常包括错误概念），定义异常处理的规范，在JDK1.4版本以后增加了异常链机制，从而便于跟踪异常。

一、异常概述

异常指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。异常发生的原因有很多，通常包含以下几大类：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。Java异常是一个描述在代码段中发生异常的对象，当发生异常情况时，一个代表该异常的对象被创建并且在导致该异常的方法中被抛出，而该方法可以选择自己处理异常或者传递该异常。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行。

二、异常分类

错误(ERROR)： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
Java异常主要分为以下两种类型的异常：
检查性异常： 最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

三、异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

网络异常，图片无法展示

* Throwable体系：
  Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
  Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法：

// 包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public void printStackTrace() : // 打印异常的详细信息。
// 提示给用户的时候,就提示错误原因。
public String getMessage() : // 获取发生异常的原因。
public String toString() : // 获取异常的类型和异常描述信息(不用)。

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?【编译时期异常和运行时期异常】

编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常) 【继承Exception】 public static void main(String[] args){ // 定义一个字符串 String str = "2020-07-24 14-30-00"; // 创建日期格式化核心对象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss"); // 将字符串转成日期数据 Date date = sdf.parse(str); //此行代码会出现错误的提示！【编译(idea中就是编写了Java源代码)阶段出现了问题！】 // 打印 System.out.println("date:" + date); } // 不处理，sdf.parse(str),那么，在编译阶段会报错，不能执行程序了。【java.text.ParseException extends Excepiton】
运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常) 【继承RuntimeException】

/* 运行阶段的异常！ */ public class Test02 {

public static void main(String[] args){
    System.out.println("start");
    int number = 100/0;  // 此行代码在程序运行的过程会报错！
    System.out.println("over");
}

}

// java.lang.ArithmeticException 【public class ArithmeticException extends RuntimeException】

编译阶段异常：必须处理！运行时异常：谁使用谁处理！也可以直接处理！

四、异常的产生过程解析

需求：在工具类中定义方法，获得int类型数组指定索引位置的元素数据，在main方法中进行测试

/*
    在工具类中定义方法，获得int类型数组指定索引位置的元素数据
 */
public class ArrayUtils {
    public static int getData(int[] array ,int index){
        // 获得指定索引位置的元素数据
        int number = array[index];
        // 返回
        return number;
    }
}
/*
    测试工具类ArrayUtils
 */
public class Test03 {
    public static void main(String[] args) {
        // 准备调用方法的2个实参
        int[] array = {10, 20, 30};
        int index = 3;
        // 调用方法
        int data = ArrayUtils.getData(array, index);
        System.out.println("data:"+ data);
    }
}

通过异常的分析：我们可以在工具类的方法里面，对传递进来的索引值数据进行判断！

五、异常的处理

5.1 抛出异常throw

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

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。
2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。
* 格式：throw new 异常类名(参数);
  throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
* 例如：
  空指针：throw new NullPointerException("你给定的对象值为null(即没有指向堆内存！)");
  数组索引越界：throw new ArrayIndexOutofBoundsException("哥们，你传递的索引值在数组中不存在！");

需求：定义方法，获得int类型数组指定索引位置的元素数据。

/*
    抛出异常：throw的使用！
 */
public class Test04 {
    public static void main(String[] args) {
        // 准备调用方法的2个实参
        int[] array = {10, 20, 30};
        int index = 3;
        // 调用方法
        int data = getData(array, index);
        System.out.println("data:"+ data);
    }
    public static int getData(int[] array ,int index){
        // 对传递进来的参数数据进行合法的判断
        if(index <0 || index >=array.length){
            // 抛出一个异常
            throw new ArrayIndexOutOfBoundsException("哥们，你传递的索引值在数组中不存在！");
        }
        // 获得指定索引位置的元素数据
        int number = array[index];
        // 返回
        return number;
    }
}
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 哥们，你传递的索引值在数组中不存在！

5.2 声明异常throws

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

* 格式：修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }  
  关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

需求：定义方法，判断路径是否是指定文件

public class Test05 {
    public static void main(String[] args) throws IOException {
        getPath("b.txt"); // 调用者也没处理！扔给JVM了(JVM能够处理IOException)！
    }
    /**
     * 定义方法，判断路径是否是指定文件
     *
     * @param path 传递进来的路径
     * @throws IOException 可能出现的异常！【告诉调用者，这里可能会出现问题，请你处理！】
     */
    public static void getPath(String path) throws IOException {
        // 对传递进来的数据进行处理
        if (!"a.txt".equals(path)) {
            // 说明不是a.txt，出现问题了！
            throw new IOException("文件给定错误！");  // 编译阶段异常！
        }
    }
}

5.3 捕获异常try…catch

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

1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
2. 在方法中使用try-catch的语句块来处理异常。

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

* 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
    try{
         编写可能会出现异常的代码
    }catch(异常类型  e){
         处理异常的代码
         //记录日志/打印异常信息/继续抛出异常
    }

注意：try和catch都不能单独使用,必须连用。

需求：定义方法，判断路径是否是指定文件

/*
    异常捕获：try...catch的使用
    定义方法，判断路径是否是指定文件
 */
public class Test06 {
    public static void main(String[] args){
        // 使用try...catch捕获异常！
        try {
            // 可能出现异常的代码！
            getPath("b.txt");  // 这行代码若没有出现异常，就不会进入catch，反之会进入！
        } catch (IOException e) {
            // 记录日志或者打印异常信息或者继续抛！
            e.printStackTrace(); // 打印日志堆栈信息！
            // throw new Exception(e);  // 这么干需要在方法上面进行throws声明！
        }
    }
    /**
     * 定义方法，判断路径是否是指定文件
     * @param path 传递进来的路径
     * @throws IOException 可能出现的异常！【告诉调用者，这里可能会出现问题，请你处理！】
     */
    public static void getPath(String path) throws IOException {
        // 对传递进来的数据进行处理
        if (!"a.txt".equals(path)) {
            // 说明不是a.txt，出现问题了！
            throw new IOException("文件给定错误！");  // 编译阶段异常！
        }
    }
}

如何获取异常信息：

public String getMessage() : // 获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。)
public String toString() : // 获取异常的类型和异常描述信息(不用)。
public void printStackTrace() : // 打印异常的跟踪栈信息并输出到控制台。

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

5.4 finally 代码块

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

* 什么样的代码适合放在finally代码块中？
  磁盘文件读写流的关闭
  网络连接的关闭
  数据库连接对象资源的释放
* ﬁnally的语法:
  try{
    // 开启资源
    // 编写可能会出现异常的代码 【编写功能代码】
  }catch(){
    处理异常的代码
        //记录日志/打印异常信息/继续抛出异常
  }ﬁnally{
    自身需要处理异常,最终还得关闭资源。【这里的代码，必定会执行！】
    // 关闭资源
  }
public class Test07 {
    public static void main(String[] args) {
        try {
            System.out.println("start");
            System.out.println("建立资源的连接");
            // 执行功能代码
            System.out.println("正在进行文件拷贝！");
            // 模拟文件拷贝出现了问题
            int number = 1 / 0;
        }catch (ArithmeticException e){
            e.printStackTrace();
        }finally {
            // 释放资源
            System.out.println("释放资源");
            System.out.println("over");
        }
    }
}

注意：ﬁnally不能单独使用。

* 常用写法组合
  ① try...catch...finally
        try {
        }catch (Exception e){
        }finally {
        } 
  ② try...finally  【这种写法，更多的是为了让finally里面的代码一定执行！】
        try{
        }finally{
        }
  ③ try...catch
        try{
        }catch(Exception e){
        }

5.5 异常注意事项

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

public static void method(){ // 此处可以不用声明异常！【后面调用的时候，也可以不用捕获！】\
    System.out.println("start");\
    int number = 0;\
    if(number==0){\
    // 抛出异常 【ArithmeticException：运行时异常！】\
    throw new ArithmeticException("除数不能为0！");\
    }\
    int i = 1/number;\
    System.out.println("over");\
    }
-   如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子集。\
    /*\
    如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子集。\
    */\
    public class Fu {\
    }\
    /*\
    如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子集。\
    */\
    public class Zi extends Fu {\
    }
    ```

public void show() throws IOException, ClassNotFoundException { String str = "a.txt"; if("b.txt".equals(str)){ throw new IOException("文件路径不对！"); }else if("c.txt".equals(str)){ throw new ClassNotFoundException("文件未找到！"); } }

@Override public void show() { try { super.show(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } }

-   父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出\
    /*\
    父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出\
    */\
    public class Fu {\
    public void method(){\
    }\
    /*\
    父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出\
    */\
    public class Zi extends Fu {\
    [@Override](</Override >)\
    public void method() {\
    super.method();\
    // 定义一个字符串\
    String str = "202-07-24 14-30-00";\
    }
      // 创建日期格式化核心对象
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
      // 将字符串转成日期数据
      try {
          Date date = sdf.parse(str);  // 此处只能捕获异常，不能声明抛出！
      } catch (ParseException e) {
          e.printStackTrace();
      }
  }

当多异常分别处理时，捕获处理，前边的类不能是后边类的父类\

public void show() {\
    try {\
    super.show();\
    } catch (Exception e) {\
    e.printStackTrace();\
    } catch (ClassNotFoundException e) { // 此处报错！【捕获(catch)的处理，前面的Exception是后面的ClasNotFoundException的父类！】\
    e.printStackTrace();\
    }\
    }
-   在try/catch后可以追加ﬁnally代码块，其中的代码一定会被执行，通常用于资源回收。\
    public static void main(String[] args) {\
    }

try { System.out.println("start"); System.out.println("建立资源的连接");

// 执行功能代码
   System.out.println("正在进行文件拷贝！");
   // 模拟文件拷贝出现了问题
   int number = 1 / 0;

}catch (ArithmeticException e){ e.printStackTrace(); }finally { // 释放资源 System.out.println("释放资源"); System.out.println("over"); }

多个异常使用捕获又该如何处理呢？
1.  1.  多个异常分别处理。
    1.  多个异常一次捕获，多次处理。【处理具体的异常(异常子类对象) IOException ClassNotFountExcetption】
    1.  多个异常一次捕获一次处理。【一次行catch异常父类对象Exception】\
        一般我们是使用一次捕获多次处理方式，格式如下：
try{\
    编写可能会出现异常的代码\
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.\
    处理异常的代码\
    //记录日志/打印异常信息/继续抛出异常\
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.\
    处理异常的代码\
    //记录日志/打印异常信息/继续抛出异常\
}

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

六、自定义异常

6.1 自定义异常概述

为什么需要自定义异常类? 我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。,例如年龄负数问题,考试成绩负数问题。在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？
异常类如何定义?

自定义一个编译期异常: 自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。

6.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

/*
    自定义异常类！继承于java.lang.Exception
 */
public class LoginException extends Exception{
    // 空参构造！
    public LoginException() {
    }
    // 带参构造【alt+insert----->>> constructor---->>> 选第二个】
    public LoginException(String message) {
        super(message);
    }
}
/*
    要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 */
public class TestRegister {
    // 模拟数据库中已经被注册过的用户
    public static ArrayList<String> names = new ArrayList<>();
    static{
        Collections.addAll(names,"jack","rose","tom");
    }
    public static void register(String name) throws UserNameIsNullException, RegisterException {
        // 非空判断
        if(name==null || "".equals(name)){
            throw new UserNameIsNullException("哥们，用户名不能为空！");
        }
        // 已注册的判断
        for (String s : names) {
            if(s.equals(name)){
                throw new RegisterException("哥们，该用户名已经被注册过了，请重新选择一个吧！");
            }
        }
        // 开始注册
        names.add(name);
    }
    public static void main(String[] args) throws RegisterException, UserNameIsNullException {
        // 调用方法
        register("lucy");
    }
}

Java基础篇 - 异常机制

前言

一、异常概述

二、异常分类

三、异常体系

四、异常的产生过程解析

五、异常的处理

5.1 抛出异常throw

5.2 声明异常throws

5.3 捕获异常try…catch

5.4 finally 代码块

5.5 异常注意事项

六、自定义异常

6.1 自定义异常概述

6.2 自定义异常的练习

后记

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java基础篇 - 异常机制

前言

一、异常概述

二、异常分类

三、异常体系

四、 异常的产生过程解析

五、异常的处理

5.1 抛出异常throw

5.2 声明异常throws

5.3 捕获异常try…catch

5.4 finally 代码块

5.5 异常注意事项

六、自定义异常

6.1 自定义异常概述

6.2 自定义异常的练习

后记

热门文章

最新文章

相关课程

相关电子书

相关实验场景

四、异常的产生过程解析