异常的捕获和处理

樱桃桃桃桃桃

于 2023-08-30 21:54:48 发布

阅读量590

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_57229804/article/details/132585542

版权

2.2.2使用try-catch-finally处理异常

一、异常

1.异常概述

1.1认识异常

异常是指程序在运行过程中出现的非正常情况。

public class Main {

    public static void main(String[] args) {
        int i=1,j=0,res;
        System.out.println("begin");
        res=i/j;//算术运算异常
        System.out.println("end");
    }

}

一旦程序发生异常将会立即结束，因此“end”没有输出。

1.2Java异常体系结构

异常在Java中被封装成了各种异常类。

程序中常见的异常：

Exception	设计时异常	异常层次结构的根类
IOException	设计时异常	IO异常的根类，属于非运行时异常
FileNotFoundException	设计时异常	文件操作时，找不到文件
RuntimeException	运行时异常	运行时异常的根类，RuntimeException及其子类，不要求必须处理
ArithmeticException	运行时异常	算术运算异常
lllegalArgumentException	运行时异常	方法接收到非法参数
ArrayIndexOutOfBoundsException	运行时异常	数组越界访问异常
NullPointerException	运行时异常	尝试访问null对象的成员时发生的空指针异常
ArrayStoreException	运行时异常	数据存储异常，写数组操作时，对象或数据类型不兼容
ClassCastException	运行时异常	类型转换异常
IIIegalThreadStateException	运行时异常	试图非法改变线程状态，例如试图启动一个已经运行的线程
NumberFormatException	运行时异常	数据格式异常，试图把一字符串非法转换成数值

2.Java异常处理机制

2.1异常处理

Java中的异常处理机制依靠5个关键字：try、catch、finally、throw、throws。这些关键字提供了两种异常处理方式：

（1）用try、catch、finally来捕获和处理异常

try块中包含可能会抛出异常的代码

catch块中用户捕获和处理指定类型的异常

finally块中的代码无论是否发生异常都会被执行，通常用于释放资源或清理操作

（2）使用throw、throws来抛出异常

throw关键字用于手动抛出异常对象。

throws关键字用于在方法声明中指定可能抛出的异常类型，表示该方法可能会抛出该类型的异常，由调用者来处理。

2.2捕获异常

2.2.1使用try-catch捕获异常

public class Main {

    public static void main(String[] args) {
        try {
            int i=1,j=0,res;
            System.out.println("begin");
            res=i/j;
            System.out.println("end");
        }catch (Exception e){
            System.out.println("caught");
            e.printStackTrace();
        }
        System.out.println("over");
    }

}

如果try语句块中的所有语句正常执行完毕，没有发生异常，那么catch语句块中的所有语句将被忽略。
如果try语句块在执行过程中发生异常，并且这个异常与catch语句块中声明的异常类型匹配，那么try语句块中剩下的代码都将被忽略，相应的catch语句块将会被执行。匹配是指catch中所处理的异常类型与try中发生的异常类型完全一致或者是它的父类。
如果try语句块在执行过程中发生异常，而抛出的异常在catch语句块中没有被声明，那么程序立即终止运行，程序被强迫退出。
catch语句块中可以加入用戶自定义处理信息，也可以调用异常对象的方法输出异常信息，常用的方法如下：
void prinStackTrace() ：输出异常的堆栈信息。堆栈信息包括程序运行到当前类的执行流程，它将输出从方法调用处到异常抛出处的方法调用的栈序列。
String getMessage() ：返回异常信息描述字符串，该字符串描述了异常产生的原因，是 printStackTrace() 输出信息的一部分。

2.2.2使用try-catch-finally处理异常

无论try块中是否发生异常，finally语句块中的代码总能被执行。

public class Main {

    public static void main(String[] args) {
        try {
            int i=1,j=0,res;
            System.out.println("begin");
            res=i/j;
            System.out.println("end");
        }catch (ArithmeticException e){
            System.out.println("caught");
            e.printStackTrace();
        }finally {
            System.out.println("finally");
        }
        System.out.println("over");
    }

}

如果try语句块中所有语句正常执行完毕，程序不会进入catch语句块执行，但是finally语句块会被执行。
如果try语句块在执行过程中发生异常，程序会进入到catch语句块捕获异常， finally语句块也会被执行。
try-catch-finally结构中try语句块是必须存在的，catch、finally语句块为可选，但两者至少出现其中之一。

即使在catch语句块中存在return语句，finally语句块中的语句也会执行。发生异常时的执行顺序是，先执行catch语句块中return之前的语句，再执行finally语句块中的语句，最后执行catch语句块中的return语句退出。

finally语句块中语句不执行的唯一情况是在异常处理代码中执行了 System.exit(1) ，退出Java虚拟机。

public class Main {

    public static void main(String[] args) {
        try {
            int i=1,j=0,res;
            System.out.println("begin");
            res=i/j;
            System.out.println("end");
        }catch (ArithmeticException e){
            System.out.println("caught");
            e.printStackTrace();
            System.exit(1);
        }finally {
            System.out.println("finally");
        }
        System.out.println("over");
    }

}

public class Main {

    public static void main(String[] args) {
        System.out.println(method());
    }

    private static int method() {
        int i=1;
        try {
            i++;//2
            System.out.println("try block,i="+i);//try block,i=2
            return i;//2
        }catch (Exception e){
            i++;
            System.out.println("catch block,i="+i);
        }finally {
            i=10;
            System.out.println("finally block,i="+i);//finally block,i=10
        }
        return i;
    }
}

public class Main {

    public static void main(String[] args) {
        System.out.println(method());
    }

    private static int method() {
        int i=1;
        try {
            i++;
            System.out.println("try block,i="+i);//try block,i=2
            return i;
        }catch (Exception e){
            i++;
            System.out.println("catch block,i="+i);
            return i;
        }finally {
            i=10;
            System.out.println("finally block,i="+i);//finally block,i=10
            return i;//10
        }
    }
}

2.2.3使用多重catch处理异常

catch语句块的排列顺序必须是从子类到父类，最后一个一般是Exception类。这是因为在异常处理中，catch语句块会按照从上到下的顺序进行匹配，系统会检测每个catch语句块处理的异常类型，并执行第一个与异常类型匹配的catch语句块。如果将父类异常放在前面，子类异常的catch语句块将永远不会被执行，因为父类异常的catch语句块已经处理了异常。

一旦系统执行了与异常类型匹配的catch语句块，并执行其中的一条catch语句后，其后的catch语句块将被忽略，程序将继续执行紧随catch语句块的代码。

子类异常应该放在前面，父类异常应该放在后面。

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        try {
            System.out.println("计算开始：");
            int i,j,res;
            System.out.println("请输入被除数：");
            i=input.nextInt();
            System.out.println("请输入除数：");
            j=input.nextInt();
            res=i/j;
            System.out.println(i+"/"+j+"="+res);
            System.out.println("计算结束");
        }catch (InputMismatchException e){
            System.out.println("除数和被除数都必须是整数！");
        }catch (ArithmeticException e){
            System.out.println("除数不能为0！");
        }catch (Exception e){
            System.out.println("其他异常"+e.getMessage());
        }finally {
            System.out.println("感谢使用本程序！");
        }
        System.out.println("程序结束！");
    }


}

第一种：被除数发生异常

第二种：除数发生异常

第三种：除数为0

2.3抛出异常

2.3.1使用throws声明抛出异常

如果在一个方法体内抛出了异常，并希望调用者能够及时地捕获异常，Java语言中通过关键字throws声明某个方法可能抛出的各种异常，以通知调用者。throws可以同时声明多个异常，之间用逗号隔开。

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        try {
            divide();
        }catch (InputMismatchException e){
            System.out.println("除数和被除数都必须是整数！");
        }catch (ArithmeticException e){
            System.out.println("除数不能为0！");
        }catch (Exception e){
            System.out.println("其他异常"+e.getMessage());
        }finally {
            System.out.println("感谢使用本程序！");
        }
        System.out.println("程序结束！");
    }
    private static void divide() throws Exception{
        Scanner input=new Scanner(System.in);
        System.out.println("计算开始：");
        int i,j,res;
        System.out.println("请输入被除数：");
        i=input.nextInt();
        System.out.println("请输入除数：");
        j=input.nextInt();
        res=i/j;
        System.out.println(i+"/"+j+"="+res);
        System.out.println("计算结束");
    }

}

2.3.2使用throw抛出异常

在Java语言中，可以使用throw关键字来自行抛出异常。

package structure;

public class Main {
    public static void main(String[] args) {
        Person1 person=new Person1();
        try {
            person.setName("扈三娘");
            person.setAge(18);
            person.setGender("男女");
            person.print();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
class Person1{
    private String name="";
    private int age=0;
    private String gender="男";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) throws Exception{
        if ("男".equals(gender)||"女".equals(gender)){
            this.gender = gender;
        }else {
            throw new Exception("性别必须是男或女！");
        }

    }
    public void print(){
        System.out.println("姓名："+this.name+"性别："+this.gender+"年龄："+this.age);
    }
}

如果 throw 语句抛出的异常是 Checked 异常，则该 throw 语句要么处于 try 块里，显式捕获该异常，要么放在一个带 throws 声明抛出的方法中，即把该异常交给该方法的调用者处理；
如果 throw 语句抛出的异常是 Runtime 异常，则该语句无须放在 try 块里，也无须放在带 throws 声明抛出的方法中；程序既可以显式使用 try...catch来捕获并处理该异常，也可以完全不理会该异常，把该异常交给该方法调用者处理。
自行抛出Runtime 异常比自行抛出Checked 异常的灵活性更好。同样，抛出 Checked 异常则可以让编译器提醒程序员必须处理该异常。

throw和throws的区别：

1.作用不同：throw用于程序员自行产生并抛出异常，throws用于声明该方法内抛出了异常。
2.使用位置不同：throw位于方法体内部，可以作为单独的语句使用；throws必须跟在方法参数列表的后面，不能单独使用。
3.内容不同：throw抛出一个异常对象，只能是一个；throws后面跟异常类，可以跟多个。

2.4自定义异常

当JDK中的异常类型不能满足程序的需要时，可以自定义异常类。步骤：

①定义异常类，并继承Exception或者RuntimeException。

②编写异常类的构造方法，向父类构造方法传入异常描述信息，并继承父类的其他实现方法。

③实例化自定义异常对象，并在程序中使用throw抛出。

package structure;

public class Main {
    public static void main(String[] args) {
        Person1 person=new Person1();
        try {
            person.setName("扈三娘");
            person.setAge(18);
            person.setGender("男女");
            person.print();
        }catch (GenderException e){
            e.printStackTrace();
        }
    }
}
//自定义异常类
class GenderException extends Exception{
    public GenderException(String message){
        super(message);
    }
}
class Person1{
    private String name="";
    private int age=0;
    private String gender="男";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) throws GenderException{
        if ("男".equals(gender)||"女".equals(gender)){
            this.gender = gender;
        }else {
            throw new GenderException("性别必须是男或女！");
        }

    }
    public void print(){
        System.out.println("姓名："+this.name+"性别："+this.gender+"年龄："+this.age);
    }
}

自定义异常可能是编译时异常，也可能是运行时异常。

1.如果自定义异常类继承Excpetion，则是编译时异常。
特点：方法中抛出的是编译时异常，必须在方法上使用throws声明，强制调用者处理。
2.如果自定义异常类继承RuntimeException，则运行时异常。
特点：方法中抛出的是运行时异常，不需要在方法上用throws声明。

2.5异常链

有时候我们会捕获一个异常后再抛出另一个异常。

顾名思义就是将异常发生的原因一个传一个串起来，即把底层的异常信息传给上层，这样逐层抛出。

在要抛出的对象中使用 initCause() 方法，添加上一个产生异常的信息; getCause() 可以获取当前异常对象的上一个异常对象。

樱桃桃桃桃桃

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
异常的捕获和处理

异常是指程序在运行过程中出现的非正常情况。res=i/j;//算术运算异常一旦程序发生异常将会立即结束，因此“end”没有输出。当JDK中的异常类型不能满足程序的需要时，可以自定义异常类。步骤：①定义异常类，并继承Exception或者RuntimeException。②编写异常类的构造方法，向父类构造方法传入异常描述信息，并继承父类的其他实现方法。③实例化自定义异常对象，并在程序中使用throw抛出。try {person.setName("扈三娘");
复制链接

扫一扫