当前位置：首页 > news >正文

17--异常处理

news 2025/10/26 7:44:37

1、异常概述

1.1 什么是异常

异常：指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致JVM的非正常停止。

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

代码逻辑错误，只是没有得到想要的结果，例如：求a与b的和，你写成了a-b

1.2 异常的抛出机制

Java中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型的对象`，并且抛出（throw），然后程序员可以捕获(catch)到这个异常对象并处理；如果没有捕获(catch)这个异常对象，那么这个异常对象将会导致程序终止。

举例：

运行下面的程序，程序会产生一个数组角标越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生和抛出的过程。

public class ArrayTools {// 对给定的数组通过给定的角标获取元素。public static int getElement(int[] arr, int index) {int element = arr[index];return element;}
}

测试类：

public class ExceptionDemo {public static void main(String[] args) {int[] arr = { 34, 12, 67 };intnum = ArrayTools.getElement(arr, 4)System.out.println("num=" + num);System.out.println("over");}
}

上述程序之星过程图解：

1.3 如何对待异常

对于程序出现的异常，一般有两种解决方法：一是遇到错误就终止程序的运行。另一种方法是程序员在编写程序时，就充分考虑到各种可能发生的异常和错误，极力预防和避免。实在无法避免的，要编写相应的代码进行异常的检测、以及异常的处理，保证代码的健壮性。

2、Java异常体系

2.1 Throwable

java.lang.Throwable 类是Java程序执行过程中发生的异常事件对应的类的根父类。

Throwable中的常用方法：

public void printStackTrace()：打印异常的详细信息。包含了异常的类型、异常的原因、异常出现的位置、在开发和调试阶段都得使用printStackTrace。
public String getMessage()：获取发生异常的原因。

2.2 Error 和 Exception

Throwable可分为两类：Error和Exception。分别对应着java.lang.Error与java.lang.Exception两个类。

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

例如：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存溢出，简称OOM）。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。例如：

空指针访问
试图读取不存在的文件
网络连接中断
数组角标越界

2.3 编译时异常和运行时异常

Java程序的执行分为编译时过程和运行时过程。有的错误只有在运行时才会发生。比如：除数为0，数组下标越界等。

因此，根据异常可能出现的阶段，可以将异常分为：

编译时期异常（即checked异常、受检异常）：在代码编译阶段，编译器就能明确警示当前代码可能发生（不是一定发生）xx异常，并明确督促程序员提前编写处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判定编译失败，从而不能生成字节码文件。通常，这类异常的发生不是由程序员的代码引起的，或者不是靠加简单判断就可以避免的，例如：FileNotFoundException（文件找不到异常）。
运行时期异常（即runtime异常、unchecked异常、非受检异常）：在代码编译阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何提示。只有等代码运行起来并确实发生了xx异常，它才能被发现。通常，这类异常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免。

- java.lang.RuntimeException类及它的子类都是运行时异常。比如：ArrayIndexOutOfBoundsException数组下标越界异常，ClassCastException类型转换异常。

3、常见的错误和异常

3.1 Error

最常见的就是VirtualMachineError，它有两个经典的子类：StackOverflowError、OutOfMemoryError。

import org.junit.Test;public class TestStackOverflowError {@Testpublic void test01(){//StackOverflowErrorrecursion();}public void recursion(){ //递归方法recursion(); }
}

import org.junit.Test;public class TestOutOfMemoryError {@Testpublic void test02(){//OutOfMemoryError//方式一：int[] arr = new int[Integer.MAX_VALUE];}@Testpublic void test03(){//OutOfMemoryError//方式二：StringBuilder s = new StringBuilder();while(true){s.append("atguigu");}}
}

3.2 运行时异常

import org.junit.Test;import java.util.Scanner;public class TestRuntimeException {@Testpublic void test01(){//NullPointerExceptionint[][] arr = new int[3][];System.out.println(arr[0].length);}@Testpublic void test02(){//ClassCastExceptionObject obj = 15;String str = (String) obj;}@Testpublic void test03(){//ArrayIndexOutOfBoundsExceptionint[] arr = new int[5];for (int i = 1; i <= 5; i++) {System.out.println(arr[i]);}}@Testpublic void test04(){//InputMismatchExceptionScanner input = new Scanner(System.in);System.out.print("请输入一个整数：");//输入非整数int num = input.nextInt();input.close();}@Testpublic void test05(){int a = 1;int b = 0;//ArithmeticExceptionSystem.out.println(a/b);}
}

3.3 编译时异常

import org.junit.Test;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;public class TestCheckedException {@Testpublic void test06() {Thread.sleep(1000);//休眠1秒  InterruptedException}@Testpublic void test07(){Class c = Class.forName("java.lang.String");//ClassNotFoundException}@Testpublic void test08() {Connection conn = DriverManager.getConnection("....");  //SQLException}@Testpublic void test09()  {FileInputStream fis = new FileInputStream("尚硅谷Java秘籍.txt"); //FileNotFoundException}@Testpublic void test10() {File file = new File("尚硅谷Java秘籍.txt");FileInputStream fis = new FileInputStream(file);//FileNotFoundExceptionint b = fis.read();//IOExceptionwhile(b != -1){System.out.print((char)b);b = fis.read();//IOException}fis.close();//IOException}
}

4、异常处理

4.1 异常处理概述

4.1.1 Java异常处理

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

4.1.2 Java异常处理的方式

方式一：try-catch-finally

方式二：throws + 异常类型

4.2 方式1：捕获异常(try-catch-finally)

过程1：“抛”

        程序在执行的过程当中，一旦出现异常，就会在出现异常的代码处，生成对应异常类的对象，并将此对象抛出。

        一旦抛出，此程序就不执行其后的代码了。

过程2：“抓”

        针对于过程1中抛出的异常对象，进行捕获处理。此捕获处理的过程，就称为抓。

        一旦将异常进行了处理，代码就可以继续执行。

4.2.1 try-catch-finally基本格式

捕获异常语法如下：

try{......	//可能产生异常的代码
}
catch( 异常类型1 e ){......	//当产生异常类型1型异常时的处置措施
}
catch( 异常类型2 e ){...... 	//当产生异常类型2型异常时的处置措施
}
finally{...... //无论是否发生异常，都无条件执行的语句
}

4.2.2 使用举例

举例1：

public class IndexOutExp {public static void main(String[] args) {String friends[] = { "lisa", "bily", "kessy" };try {for (int i = 0; i < 5; i++) {System.out.println(friends[i]);}} catch (ArrayIndexOutOfBoundsException e) {System.out.println("index err");}System.out.println("\nthis is the end");}
}

举例2：

public class DivideZero1 {int x;public static void main(String[] args) {int y;DivideZero1 c = new DivideZero1();try {y = 3 / c.x;} catch (ArithmeticException e) {System.out.println("divide by zero error!");}System.out.println("program ends ok!");}
}

4.2.3 finally使用及举例

举例1：确保资源关闭

import java.util.InputMismatchException;
import java.util.Scanner;public class TestFinally {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {System.out.print("请输入第一个整数：");int a = input.nextInt();System.out.print("请输入第二个整数：");int b = input.nextInt();int result = a/b;System.out.println(a + "/" + b +"=" + result);} catch (InputMismatchException e) {System.out.println("数字格式不正确，请输入两个整数");}catch (ArithmeticException e){System.out.println("第二个整数不能为0");} finally {System.out.println("程序结束，释放资源");input.close();}}@Testpublic void test1(){FileInputStream fis = null;try{File file = new File("hello1.txt");fis = new FileInputStream(file);//FileNotFoundExceptionint b = fis.read();//IOExceptionwhile(b != -1){System.out.print((char)b);b = fis.read();//IOException}}catch(IOException e){e.printStackTrace();}finally{try {if(fis != null)fis.close();//IOException} catch (IOException e) {e.printStackTrace();}	}}
}

举例2：从try回来

public class FinallyTest1 {public static void main(String[] args) {int result = test("12");System.out.println(result);}public static int test(String str){try{Integer.parseInt(str);return 1;}catch(NumberFormatException e){return -1;}finally{System.out.println("test结束");}}
}

举例3：从catch回来

public class FinallyTest2 {public static void main(String[] args) {int result = test("a");System.out.println(result);}public static int test(String str) {try {Integer.parseInt(str);return 1;} catch (NumberFormatException e) {return -1;} finally {System.out.println("test结束");}}
}

举例4：从finally回来

public class FinallyTest3 {public static void main(String[] args) {int result = test("a");System.out.println(result);}public static int test(String str) {try {Integer.parseInt(str);return 1;} catch (NumberFormatException e) {return -1;} finally {System.out.println("test结束");return 0;}}
}

4.2.4 使用细节

1、将可能出现异常的代码声明在try语句中。一旦代码出现异常，就会自动生成一个对应异常类的对象。并将此对象抛出。

2、针对于try中抛出的异常类的对象，使用之后的catch语句进行匹配。一旦匹配上，就进入catch语句块进行处理。

        一旦处理结束，代码就可继续向下执行。

3、如果声明了多个catch结构，不同的异常类型在不存在子父类关系的情况下，谁声明在上面，谁声明在下面都可以。

        如果多个异常类型满足子父类的关系，则必须将子类声明在父类结构的上面。否则，报错。

4、catch中异常处理的方式：

        ① 自己编写输出的语句。

        ② printStackTrace()：打印异常的详细信息。（推荐）

        ③ getMessage()：获取发生异常的原因。

5、try中声明的变量，出了try结构之后，就不可以进行调用了。

6、try-catch结构是可以嵌套使用的。

7、catch和finally是可选的，但是finally不能单独使用。

4.2.5 finally的使用说明

finally的理解：

我们将一定要被执行的代码声明在finally结构中。

更深刻的理解：无论try中或catch中是否存在仍未被处理的异常，无论try中或catch中是否存在return语句等，finally中声明的语句都一定要被执行。

finally写入什么样的代码：

我们在开发中，有一些资源（比如：输入流、输出流，数据库连接、Socket连接等资源），在使用完以后，必须显式的进行关闭操作，否则，GC不会自动的回收这些资源。进而导致内存的泄漏。

为了保证这些资源在使用完以后，不管是否出现了未被处理的异常的情况下，这些资源能被关闭。我们必须将这些操作声明在finally中！

4.3 方式2：声明抛出异常类型(throws)

具体方式：在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

4.3.1 throws基本格式

修饰符返回值类型方法名(参数) throws 异常类名1,异常类名2…{ }

public void readFile(String file)  throws FileNotFoundException,IOException {...// 读文件的操作可能产生FileNotFoundException或IOException类型的异常FileInputStream fis = new FileInputStream(file);//...
}

4.3.2 throws使用举例

举例1：针对于编译时异常

public class TestThrowsCheckedException {public static void main(String[] args) {System.out.println("上课.....");try {afterClass();//换到这里处理异常} catch (InterruptedException e) {e.printStackTrace();System.out.println("准备提前上课");}System.out.println("上课.....");}public static void afterClass() throws InterruptedException {for(int i=10; i>=1; i--){Thread.sleep(1000);//本来应该在这里处理异常System.out.println("距离上课还有：" + i + "分钟");}}
}

举例2：针对于运行时异常

throws后面也可以写运行时异常类型，只是运行时异常类型，写或不写对于编译器和程序执行来说都没有任何区别。如果写了，唯一的区别就是调用者调用该方法后，使用try...catch结构时，IDEA可以获得更多的信息，需要添加哪种catch分支。

import java.util.InputMismatchException;
import java.util.Scanner;public class TestThrowsRuntimeException {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {System.out.print("请输入第一个整数：");int a = input.nextInt();System.out.print("请输入第二个整数：");int b = input.nextInt();int result = divide(a,b);System.out.println(a + "/" + b +"=" + result);} catch (ArithmeticException | InputMismatchException e) {e.printStackTrace();} finally {input.close();}}public static int divide(int a, int b)throws ArithmeticException{return a/b;}
}

throws是否真正处理了异常？

从编译是否能通过的角度看，看成是给出了异常万一要是出现时候的解决方案。此方案就是，继续向上抛出(throws)。

但是，此throws的方式，仅是将可能出现的异常抛给了此方法的调用者。此调用者仍然需要考虑如何处理相关异常。

从这个角度来看，throws的方式不算是真正意义上处理了异常。

4.3.3 方法重写中throws的要求

子类重写的方法抛出的异常类型可以与父类被重写的方法抛出的异常类型相同，或是父类被重写的方法抛出的异常类型的子类。

import java.io.IOException;class Father{public void method()throws Exception{System.out.println("Father.method");}
}
class Son extends Father{@Overridepublic void method() throws IOException,ClassCastException {System.out.println("Son.method");}
}

4.4 两种异常处理方式的选择

前提：对于异常，使用相应的处理方式。此时的异常，主要指的是编译时异常。

如果程序代码中，涉及到资源的调用（流、数据库连接、网络连接等），则必须考虑使用try-catch-finally来处理，保证不出现内存泄漏。
如果父类被重写的方法没有throws异常类型，则子类重写的方法中如果出现异常，只能考虑使用try-catch-finally进行处理，不能throws。
开发中，方法a中依次调用了方法b,c,d等方法，方法b,c,d之间是递进关系。此时，如果方法b,c,d中有异常，我们通常选择使用throws，而方法a中通常选择使用try-catch-finally。

5、手动抛出异常对象：throw

Java 中异常对象的生成有两种方式：

由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，那么针对当前代码，就会在后台自动创建一个对应异常类的实例对象并抛出。
由开发人员手动创建：new 异常类型([实参列表]);，如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但是一旦throw抛出，就会对程序运行产生影响了。

5.1 使用格式

throw new 异常类名(参数);

throw语句抛出的异常对象，和JVM自动创建和抛出的异常对象一样。

如果是编译时异常类型的对象，同样需要使用throws或者try...catch处理，否则编译不通过。
如果是运行时异常类型的对象，编译器不提示。
可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：throw new String("want to throw");

5.2 使用注意点

无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被try..catch合理的处理，都会导致程序崩溃。

throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行。

如果当前方法没有try...catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者。

public class TestThrow {public static void main(String[] args) {try {System.out.println(max(4,2,31,1));} catch (Exception e) {e.printStackTrace();}try {System.out.println(max(4));} catch (Exception e) {e.printStackTrace();}try {System.out.println(max());} catch (Exception e) {e.printStackTrace();}}public static int max(int... nums){if(nums == null || nums.length==0){throw new IllegalArgumentException("没有传入任何整数，无法获取最大值");}int max = nums[0];for (int i = 1; i < nums.length; i++) {if(nums[i] > max){max = nums[i];}}return max;}
}

如何理解"自动 vs 手动"抛出异常对象？

过程1：“抛”

        "自动抛" ：程序在执行的过程当中，一旦出现异常，就会在出现异常的代码处，自动生成对应异常类的对象，并将此对象抛出。

        "手动抛" ：程序在执行的过程当中，不满足指定条件的情况下，我们主动的使用"throw + 异常类的对象"方式抛出异常对象。

过程2：“抓”

        狭义上讲：try-catch的方式捕获异常，并处理。

        广义上讲：把“抓”理解为“处理”。则此时对应着异常处理的两种方式：① try-catch-finally ② throws

6、自定义异常

6.1 为什么需要自定义异常

Java中不同的异常类，分别表示着某一种具体的异常情况。那么在开发中总是有些异常情况是核心类库中没有定义好的，此时我们需要根据自己业务的异常情况来定义异常类。例如年龄负数问题，考试成绩负数问题，某员工已在团队中等。

我们其实更关心的是，通过异常的名称就能直接判断此异常出现的原因。既然如此，我们就有必要在实际开发场景中，不满足我们指定的条件时，指明我们自己特有的异常类。通过此异常类的名称，就能判断出具体出现的问题。

6.2 自定义异常

（1）要继承一个异常类型

自定义一个编译时异常类型：自定义类继承java.lang.Exception。

自定义一个运行时异常类型：自定义类继承java.lang.RuntimeException。

（2）建议大家提供至少两个构造器，一个是无参构造，一个是(String message)构造器。

（3）自定义异常需要提供serialVersionUID

如何使用自定义异常类？

在具体的代码中，满足指定条件的情况下，需要手动的使用"throw + 自定义异常类的对象"方式，将异常对象抛出。

如果自定义异常类是非运行时异常，则必须考虑如何处理此异常类的对象。（具体的：① try-catch-finally ② throws）

6.3 注意点

自定义的异常只能通过throw抛出。
自定义异常最重要的是异常类的名字和message属性。当异常出现时，可以根据名字判断异常类型。比如：TeamException("成员已满，无法添加");、 TeamException("该员工已是某团队成员");
自定义异常对象只能手动抛出。抛出后由try..catch处理，也可以甩锅throws给调用者处理。

6.4 举例