【Java零基础入门篇】第 ⑥ 期 - 异常处理

命运之光

已于 2023-05-11 19:48:27 修改

阅读量1.1k

点赞数 11

分类专栏：从零开始：Java面向对象初学者指南文章标签： java jvm 开发语言

于 2023-05-09 17:19:25 首次发布

本文链接：https://blog.csdn.net/VLOKL/article/details/130584551

版权

从零开始：Java面向对象初学者指南专栏收录该内容

15 篇文章 50 订阅

订阅专栏

博主：命运之光
专栏：Java零基础入门

学习目标

掌握异常的概念，Java中的常见异常类；

掌握Java中如何捕获和处理异常；

掌握自定义异常类及其使用；

方式一：try – catch - finally

异常概述

程序员在写代码的时候即便写的尽善尽美，在系统的运行过程中依据会遇到一些问题，因为很多问题不是靠代码能够避免的。

异常体系

🍓🍓异常是处理运行时错误的特殊类，所有异常类都是java.lang.Throwable的子类，Throwable 类是类库java.Lang 包中的一个类，它派生了两个子类：Exception和Error。

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。必须修改代码，程序才可以继续执行。
Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空指针访问、试图读取不存在的文件、网络连接中断、数组下标越界等。

Exception分为：运行时异常（非受检异常）；编译时异常（受检异常）

编译时异常：类型上都属于Exception类及其子类。编译时为了保证程序的健壮性 ，可以提前预料到的异常，从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。

运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，也会编译通过。

常见的异常

1.ArithmeticException 异常

算术运算异常，当除数为零时就会产生此类异常。

例如：int x=2/0; //此时会发生ArithmeticException异常

2.ArrayIndexOutOfBoundsException异常

访问数组元素的下标越界异常，当访问的数组元素的下标超过数组的上下界时发生此类异常。

例如： int a[]=new int[3]; //定义了数组a,下标从0到2是合法的 int x=a[3]; //下标超过上界，此时会发生ArrayIndexOutOfBoundsException异常

3.ArrayStoreException异常

数组存储异常，当数组存储空间不够或类型不匹配时会产生此类异常。

例如： int a[]=new int[5]; String b=new String[5]; String.arraryCopy(a,b); //类型不匹配会产生ArrayStoreException异常

4. NegativeArraySizeException异常

负值数组大小异常，当数组的存储单元个数为负数时会产生此类异常。例如： int a[]=new int[-5]; //数组个数大小为负数，发生NegativeArraySizeException异常。

5.IndexOutOfBoundsException异常

索引（下标）越界异常，是ArrayIndexOutOfBoundsException的父类。例如： String s=”abc123”; s.charAt(8); // 下标8越界，发生IndexOutOfBoundsException异常

6.NullPointerException异常

访问空引用（指针）异常。例如： String s=null; s.charAt(2); //s为null,发生NullPointerException异常

7. NumberFormatException异常

数值格式异常,当数据类型格式转换不匹配时会产生此类异常。

8. ClassCaseException异常

类强制转换异常，当把一个类强制转换成另一个没有任何继承关系的类时产生此类异常。

9. StringIndexOutOfBoundsException异常

字符串下标越界异常。

10. SecurityException异常

安全性异常。

Java的异常处理机制

🍓🍓在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。

🍓🍓Java中针对各种运行错误定义了很多异常类，每个异常类都代表了一种运行错误。每当java程序运行过程中某段代码发生一个可识别的运行错误时，JVM都会产生一个相应的异常类的对象，对象封装了异常的有关信息。

Java提供的异常处理机制是采取抛出异常，然后捕获异常的处理形式，主要分为两个步骤：

抛出异常：在程序运行中当语义规则被违反时，在异常代码处即产生一个异常事件，生成一个对应异常类的对象，将此对象抛出(throw) ，其后的代码不再处理。
捕获异常：如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。

如果一个异常回到main()方法，并且main()也不处理，则程序运行终止；

程序员通常只能处理Exception，而对Error无能为力.

方式一：try – catch - finally

语法格式：

try {
    // 有可能出现异常的语句
} catch (异常类型1 对象) {
    // 异常处理 ;
} catch (异常类型2 对象) {
    // 异常处理 ;
} catch (异常类型3 对象) {
    // 异常处理 ;
} ....
finally {
    //不管是否出现异常，都执行的统一代码
}

🍓🍓例1：直接使用对应异常类作为参数(try – catch - finally)。

public class text1 {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            System.out.println("2、除法计算：" + (10 / 0));	// 此处产生异常
            // 异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("异常产生后的语句");
        } catch (ArithmeticException e) {		// 处理算术异常
            System.out.println("******** 出现异常了 *********");
        }
        System.out.println("3、除法计算结束。");
    }
}

说明：

try: 捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中，一旦出现异常，就会生成一个对应异常类的对象;
catch (Exceptiontype e): catch语句块中是对异常对象进行处理的代码。每个try 语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。

- 比如： 可以用 ArithmeticException 类（子类）作为参数的地方，就可以用 RuntimeException类(父类)作为参数，或者用所有异常的父类Exception类作为参数。

🍓🍓例2：使用异常类对应的父类作为参数(try – catch - finally)。

public class text1 {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            System.out.println("2、除法计算：" + (10 / 0));	// 此处产生异常
            // 异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("异常产生后的语句");
        } catch (RuntimeException e) {		// 处理算术异常
            System.out.println("******** 出现异常了 *********");
        }
        System.out.println("3、除法计算结束。");
    }
}

注意：

一旦try中的异常对象匹配到某一个catch时，进入catch中进行异常的处理，一旦处理完成，跳出try-catch结构（没写finally的情况），继续执行其它代码；
finally: 捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。

- 不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
- finally语句和catch语句是任选的。

🍓catch中的异常类型如果没有子父类关系，则声明顺序没有要求，谁在上均可。
🍓catch中的异常类型如果有子父类关系，则子类声明必须在父类声明之上，否则报错。

捕获异常的有关信息：

与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

getMessage() ：获取异常说明信息，返回字符串；
printStackTrace() ：输出异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

🍓🍓例3：输出异常完整信息。

public class text1 {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            System.out.println("2、除法计算：" + (10 / 0));// 此处产生异常
            // 异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("若前面代码出现异常，此行代码不会执行！");
        } catch (ArithmeticException e) {	// 处理算术异常
            e.printStackTrace();	// 输出异常的完整信息
        } finally {
            System.out.println("### 不管是否出现异常我都执行！") ;
        }
        System.out.println("3、除法计算结束。");
    }
}

方式二：throws+异常类型

🍓🍓Java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，但此方法中不处理异常。

🍓🍓这样调用者在调用方法时，就明确地知道该方法可能有异常，并且必须在程序中对异常进行处理，否则编译无法通过。

throws关键字声明抛出异常的语法格式如下：

修饰符 返回值类型 方法名（参数列表） throws 异常类型列表{
            ………
}

🍓🍓例：class MyMath

声明如下方法可能会抛出一个ArithmeticExcption或IOException类型的异常，使它的调用者知道要捕获这个异常。

class MyMath {
    public static int div(int x, int y) throws ArithmeticException, IOException {
            // 此方法不处理异常
        return x / y;
    }
}

🍓“throws + 异常类型”写在方法声明处，指明此方法执行时，可能会抛出的异常类型，一旦方法体执行时，出现异常，仍会在代码处生成一个异常的对象。此对象满足throws后的异常类型时，该对象就会被抛出。

🍓主方法也可以使用throws抛出异常，这时主方法里可以不用强制进行异常处理，而是将异常处理交给JVM进行默认处理，此时会导致程序中断。（不建议使用）

手动抛出异常

🍓🍓Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

手动创建并抛出异常,通过throw关键字。

throw语句用来直接抛出一个异常，后接一个可抛出的异常类对象。

格式如下：

throw new 异常类名(【参数列表】)；

或

异常类名 对象名 ＝new 异常类名(【参数列表】)；
throw 对象名；

例如：首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)

IOException e = new IOException( );

throw e;

或：

throw new IOException();

说明：

可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：throw new String("want to throw");

重写方法声明抛出异常的原则

一个方法被覆盖时，覆盖它的方法必须抛出跟被覆盖的方法相同的异常或者异常的子类，或者不抛出异常;
如果父类抛出多个异常，那么重写（覆盖）的方法必须抛出那些异常的一个子集，也就是说不能抛出新的异常。

throws和throw的区别：

首先throws出现在方法函数头(声明处)，表示若抛出异常，由该方法的调用者来处理；
throw出现在函数体，表示在方法中手工抛出一个异常。

自定义异常

🍓🍓创建用户定义的异常类，可通过扩充（继承）Exception类来创建自己的异常类，被扩充的异常类继承Exception类的属性和方法，具有异常类全部特性，同时也和任何其他类一样，可以有数据成员、构造方法及其他功能性的成员方法。

自定义异常类后，创建异常类对象，最后再使用throw语句抛出该异常对象，在调用点添加异常处理语句即可。

自定义异常步骤

第1步：自定义异常类。例如：

class MyException extends Exception {
        ……
}

第2步：定义异常对象，并抛出该对象。

方式1：

throw new MyException ( );

方式2：

MyException e = new MyException( );
throw e;

命运之光

关注

11
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
17
评论
【Java零基础入门篇】第 ⑥ 期 - 异常处理

【Java零基础入门篇】第 ⑥ 期 - 异常处理
复制链接

扫一扫

专栏目录