【一文看懂Java异常：代码故障的解谜之旅】

于 2024-01-15 00:13:56 发布
阅读量1k 收藏 26
点赞数 24
分类专栏： JavaSE 文章标签： java 开发语言 异常
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheMyth142857/article/details/135433915
版权

前言：当我们编写程序时，有时会遇到一些意外的情况，比如输入错误、文件找不到、或者网络连接失败。这些问题可能会让程序崩溃，但在Java中，我们有一种叫做"异常"的机制，可以帮助我们更好地应对这些问题。在学习异常之前我们还是通过一些基础案例由浅入深来讲解为什么要用异常，怎么使用异常等。

我们先通过几个案例来演示下什么是异常？

第一种情况：

import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数：求商：
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个数：");
        int num1 = sc.nextInt();
        System.out.println("请录入第二个数：");
        int num2 = sc.nextInt();
        System.out.println("商："+num1/num2);
    }
}

以上这段代码看似没有什么问题，我们进行正常的输入int类型的值之后结果没问题。

但是在测试其它类型的数据，例如非int类型的数据时候，此时就会出现异常了。 

或者除数为0的时候： 

第二种情况：

 public class Test {
     //这是一个main方法，是程序的入口：
     public static void main(String[] args) {
         int[] arr = {1, 2, 3};
         System.out.println(arr[100]);
     }
 }

 比较经典的数组越界异常：

第三种情况：

 public class Test {
     //这是一个main方法，是程序的入口：
     public static void main(String[] args) {
         int[] arr = null;
         System.out.println(arr.clone());
     }
 }

也是比较经典的异常之一：空指针异常 

以上情况都属异常，只是列举了一些常见的而已。

异常：Exception：在程序的运行过程中，发生了不正常的现象，阻止了程序的运行，我们称之为异常。
异常其实就是一个类。

我们回想一下，当我们还没有学习异常时候，我们是如何处理这些情况的呢？通过简单的if-else来就解决。就拿上面的案例代码来说：

import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数：求商：
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个数：");
        if(sc.hasNextInt()){
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            if(sc.hasNextInt()){
                int num2 = sc.nextInt();
                if(num2 == 0){
                    System.out.println("对不起，除数不能为0");
                }else{
                    System.out.println("商："+num1/num2);
                }
            }else{
                System.out.println("对不起，你录入的不是int类型的数据！");
            }
        }else{
            System.out.println("对不起，你录入的不是int类型的数据！");
        }
    }
}

虽然我们通过if-else解决了一些常见的异常问题，但是用这种方法来堵漏洞也有很多缺点：

（1）代码臃肿，业务代码和处理异常的代码混在一起。
（2）可读性差
（3）程序员需要花费大量的经历来维护这个漏洞
（4）程序员很难堵住所有的漏洞。 

正是由于if-else的处理方式不方便且有很多缺点，所以Java中专门出了一个异常处理机制：

“异常三连”  try-catch-finally

try-catch

我们首先来讲try-catch部分，异常出现了我们应该怎么看？

接下来我们先用try-catch来捕获异常： 

import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test2 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数：求商：
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商："+num1/num2);
        }catch (Exception ex){
            System.out.println("对不起，你的程序出现异常！");
        }
        System.out.println("----谢谢你使用计算器111");
        System.out.println("----谢谢你使用计算器222");
        System.out.println("----谢谢你使用计算器333");
        System.out.println("----谢谢你使用计算器444");
        System.out.println("----谢谢你使用计算器555");
        System.out.println("----谢谢你使用计算器666");
    }
}

原理：
把可能出现异常的代码放入try代码块中，然后将异常封装为对象，被catch后面的()中的那个异常对象接收，接收以后：执行catch后面的{}里面的代码，然后try-catch后面的代码，该怎么执行就怎么执行。

详细说一下：

  1. try中没有异常，catch中代码不执行。
  2. try中有异常，catch进行捕获：

如果catch中异常类型和你出的异常类型匹配的话：走catch中的代码--》进行捕获
如果catch中异常类型和你出的异常类型不匹配的话：不走catch中的代码--》没有捕获成功，程序相当于遇到异常了，中断了，后续代码不执行

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
            System.out.println("after...");
        } catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("捕捉到了 ArithmeticException 异常，进行处理异常的逻辑");
        } catch (NullPointerException e) {
            e.printStackTrace();
            System.out.println("捕捉到了 NullPointerException 异常，进行处理异常的逻辑");
        }
        System.out.println("正常的逻辑");
    }
}

注意：

（1）try中如果出现异常，然后用catch捕获成功的话，那么try中后续的代码是不会执行的
（2）如果catch捕获异常成功，那么try-catch后面的代码该执行还是执行没有影响 

catch中处理异常的几种常见方式

还是对以前的案例代码做演示：

import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test3 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数：求商：
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商："+num1/num2);
        }catch (Exception ex){
            //第一种处理：什么都不写，什么都不做
            //第二种处理：输出自定义异常信息
            //System.out.println("对不起，你的程序出现异常！");
            //第三种处理：打印异常信息：
            /*(1)调用toString方法，显示异常的类名（全限定路径）*/
           /* System.out.println(ex);
            System.out.println(ex.toString());*/
           /*(2)显示异常描述信息对应的字符串，如果没有就显示null*/
           /*System.out.println(ex.getMessage());*/
           /*(3)显示异常的堆栈信息：将异常信息捕获以后，在控制台将异常的效果给我们展示出来，方便我们查看异常*/
            /*ex.printStackTrace();*///实际上用得最多
            //第四种处理：抛出异常：相当于异常重现（出现中断），异常一旦抛出，后面的代码就不会执行了
            throw ex;
        }
        System.out.println("----谢谢你使用计算器111");
    }
}

try-catch-finally

【1】在什么情况下，try-catch后面的代码不执行？
（1）throw抛出异常的情况
（2）catch中没有正常的进行异常捕获，例如：比如只能捕获输入匹配异常，如果除数为0，是另外一个异常，程序会中断
（3）在try中遇到return

【2】怎么样才可以将 try-catch后面的代码  必须执行？
只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行

【3】return和finally执行顺序？
先执行finally最后执行return

【4】finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行 finally). 
但是如果 finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return. 
一般我们不建议在 finally 中写 return (会被编译器当做一个警告)

【5】什么代码会放在finally中呢？
关闭数据库资源，关闭IO流资源，关闭socket资源

【6】有一句话代码很厉害，它可以让finally中代码不执行!
System.exit(0);//终止当前的虚拟机执行 (传入的数字无关紧要)

import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test3 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数：求商：
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商："+num1/num2);
            System.exit(0);
            return;
        }catch (Exception ex){
            //第一种处理：什么都不写，什么都不做
            //第二种处理：输出自定义异常信息
            //System.out.println("对不起，你的程序出现异常！");
            //第三种处理：打印异常信息：
            /*(1)调用toString方法，显示异常的类名（全限定路径）*/
           /* System.out.println(ex);
            System.out.println(ex.toString());*/
           /*(2)显示异常描述信息对应的字符串，如果没有就显示null*/
           /*System.out.println(ex.getMessage());*/
           /*(3)显示异常的堆栈信息：将异常信息捕获以后，在控制台将异常的效果给我们展示出来，方便我们查看异常*/
            /*ex.printStackTrace();*/
            //第四种处理：抛出异常：相当于异常重现
            throw ex;
        }finally {
            System.out.println("----谢谢你使用计算器111");
        }
    }
}

多重catch 

【1】try中出现异常以后，将异常类型跟catch后面的类型依次比较，按照代码的顺序进行比对，执行第一个与异常类型匹配的catch语句
【2】一旦执行其中一条catch语句之后，后面的catch语句就会被忽略了！
【3】在安排catch语句的顺序的时候，一般会将特殊异常放在前面（并列），一般化的异常放在后面。
先写子类异常，再写父类异常。

import java.util.InputMismatchException;
import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test4 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数：求商：
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商："+num1/num2);
        }catch(ArithmeticException ex){
            System.out.println("对不起，除数不可以为0");
        }catch(InputMismatchException ex){
            System.out.println("对不起，你录入的数据不是int类型的数据！");
        }catch(Exception ex){//写在最后
            System.out.println("对不起，你的程序出现异常");
        }finally{
            System.out.println("----谢谢你使用计算器111");
        }
    }
}

【4】在JDK1.7以后，异常新处理方式：可以并列用|符号连接： 

好的地方是一行代码可以写完，不好的地方：不能够知道具体是哪个异常出现了问题
通过下面代码引入问题： 

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
            System.out.println("after...");
        } catch (ArithmeticException | NullPointerException e) {
            e.printStackTrace();
            System.out.println("捕捉到了 ArithmeticException | NullPointerException 异常，进行处理异常的逻辑");
        }
        System.out.println("正常的逻辑");
    }
}

 

上面我们学习什么是异常，以及遇到异常如何处理，下面我们再详细介绍一下异常。

异常的分类 

【1】层次结构：

注意：程序中语法错误，逻辑错误  都不属于上面的Error，Exception 

【2】运行时异常： 

/**
 * @Auther: themyth
 */
public class Test5 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //运行时异常：
        int[] arr = {1,2,3};
        System.out.println(arr.length);
        /*int[] arr2 = null;
        System.out.println(arr2.length);*/
        System.out.println(arr[10]);
    }
}

【3】检查异常： 

处理方式1：try-catch嵌套try-catch 

/**
 * @Auther: themyth
 */
public class Test6 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //检查异常：
        try {
            try {
                Class.forName("com.test01.Test").newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

处理方式2：多重catch 

/**
 * @Auther: themyth
 */
public class Test6 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //检查异常：
        try {
            Class.forName("com.test01.Test").newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

处理方式3：throws类似于甩锅，将异常抛给JVM虚拟机，虚拟机其实不会处理异常，会把抛给它的异常在控制台打印出来 

/**
 * @Auther: themyth
 */
public class Test6 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //检查异常：
        Class.forName("com.test01.Test").newInstance();
    }
}

throw和throws的区别 

import java.util.Scanner;
/**
 * @Auther: themyth
 */
public class Test7 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws Exception {
        //实现一个功能：两个数相除，当除数为0的时候，程序出现异常。
        /*try {
            devide();
        } catch (Exception e) {
            e.printStackTrace();
        }*/
        devide();
    }
    public static void devide() throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个数：");
        int num1 = sc.nextInt();
        System.out.println("请录入第二个数：");
        int num2 = sc.nextInt();
        if (num2 == 0) {//除数为0，制造异常。
            //制造运行时异常：
            /*throw new RuntimeException();*/
            //制造检查异常：
            /*try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }*/
            throw new Exception();
        }
    }
}

图解：

总结： 

throw和throws的区别：
（1）位置不同：
throw：方法内部
throws: 方法的签名处（方法的声明处）

（2）内容不同：
throw + 异常对象（检查异常，运行时异常）
注意：

  1. 如果抛出的是检查异常/编译时异常/受查异常，必须要进行处理，要么try catch内部捕捉，要么throws往上抛
  2. 如果抛出的是运行时异常/非受查异常，无需额外处理，当然可以try-catch捕获，也可以继续throws向上抛，方便后续捕捉异常（但一般不这么做）

throws + 异常的类型（可以多个类型，用，拼接）

（3）作用不同：

throw：异常出现的源头，制造异常。
throws：在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常。然后调用者对这个异常进行处理：要么自己处理要么再继续向外抛出异常 

练习：

/**
 * @Auther: themyth
 */
public class Student {
    private String name;
    private int age;
    private String sex;
    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 getSex() {
        return sex;
    }
    public void setSex(String sex) throws Exception {
        if("男".equals(sex) || "女".equals(sex)){//sex.equals("男)这样写---》容易发生空指针异常
            this.sex = sex;
        }else{//非男非女
            //解决办法1：
            /*this.sex = "男";*/
            //解决办法2：给个友好型提示，但是打印结果为默认的null效果
            /*System.out.println("对不起，你的性别错误");*/
            //解决办法3：
            //制造运行时异常：也可以在内部用try-catch捕获，或者往上抛（一般多数人不会管运行时的异常）
            /*throw new RuntimeException("性别错误！");*/
            //制造检查异常：必须在内部用try-catch捕获，或者往上抛
            /*try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }*/
            throw new Exception();
        }
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public Student() {
    }
    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        /*this.sex = sex;*/
        try {//可在内部捕获，也可以往上抛，如果往上抛，Person构造器就需要解决抛它的异常，它也可以选择往上抛，或者在内部捕获
            this.setSex(sex);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

【异常处理流程总结】  

  1. 程序先执行 try 中的代码 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配. 
  2. 如果找到匹配的异常类型, 就会执行 catch 中的代码 
  3. 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者. 
  4. 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行). 
  5. 如果上层调用者也没有处理的了异常, 就继续向上传递. 
  6. 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

重载和重写的异常 

【1】重载： 抛出异常无关

/**
 * @Auther: themyth
 */
public class Demo {
    public void a(){
    }
    public void a(int age) throws RuntimeException{
    }
    public void a(int age,String name) throws ArithmeticException{
    }
}

【2】重写：子类 <= 父类  

 

自定义异常 

Java中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构。
【注意事项】 

自定义异常通常会继承自 Exception 或者 RuntimeException 
继承自 Exception 的异常默认是 检查异常/编译器异常/受查异常 
继承自 RuntimeException 的异常默认是 运行时异常/非受查异常.

1.继承运行时异常：

/**
 * @Auther: themyth
 */
public class MyException extends RuntimeException{
    static final long serialVersionUID = -70348971907L;
    public MyException(){
    }
    public MyException(String msg){
        super(msg);
    }
}

2.继承检查异常： 

/**
 * @Auther: themyth
 */
public class MyException extends Exception{
    static final long serialVersionUID = -70348971907L;
    public MyException(){
    }
    public MyException(String msg){
        super(msg);
    }
}

练习1：用户登陆功能异常的捕获

public class Test {
    private String name = "admin";
    private String password = "123456";
    public void login(String name, String password) {
        if (!this.name.equals(name)) {
            System.out.println("用户名错误！");
            return;
        }
        if (!this.password.equals(password)) {
            System.out.println("密码错误！");
            return;
        }
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test test = new Test();
        test.login("admin", "123");
    }
}

、

此时我们就需要去定义一些自定义的异常，如下：

public class UserNameException extends RuntimeException{
    public UserNameException() {
    }
    public UserNameException(String message) {
        super(message);
    }
}
public class PassWordException extends RuntimeException{
    public PassWordException() {
    }
    public PassWordException(String message) {
        super(message);
    }
}
public class Test {
    private String name = "admin";
    private String password = "123456";
    public void login(String name, String password) throws UserNameException, PassWordException {//这个自定义异常继承的的运行时异常，这儿进行抛出是为了后面好捕捉这个异常
        if (!this.name.equals(name)) {
            throw new UserNameException("你的用户名有错！");
        }
        if (!this.password.equals(password)) {
            throw new PassWordException("你的密码有错！");
        }
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test test = new Test();
        try {
            test.login("admin", "123");
        } catch (UserNameException e) {
            e.printStackTrace();
            System.out.println("用户名异常");
        } catch (PassWordException e) {
            e.printStackTrace();
            System.out.println("密码异常");
        }
    }
}

 

练习2：三角形三边异常的捕获 

 

import java.util.Scanner;
class IllegalTriangleException extends Exception {
    String message;//定义要显示的异常信息
    public IllegalTriangleException(double side1, double side2, double side3) {
        message = "Invalid: " + side1 + "," + side2 + "," + side3;
    }
    @Override
    public String getMessage() {
        return message;
    }
}
class Triangle {
    double side1;
    double side2;
    double side3;
    public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
        if (side1 + side2 > side3 && side1 + side3 > side2 && side2 + side3 > side1) {
            this.side1 = side1;
            this.side2 = side2;
            this.side3 = side3;
        } else {
            throw new IllegalTriangleException(side1, side2, side3);
        }
    }
    @Override
    public String toString() {
        return "Triangle [side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + "]";
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()) {
            double s1 = input.nextDouble();
            double s2 = input.nextDouble();
            double s3 = input.nextDouble();
            try {
                Triangle t = new Triangle(s1, s2, s3);
                System.out.println(t.toString());
            } catch (IllegalTriangleException ex) {
                System.out.println(ex.getMessage());//调用重写后的方法
            }
        }
    }
}

改进代码：

import java.util.Scanner;
class IllegalTriangleException extends Exception {
    
    public IllegalTriangleException(String message) {//IDEA生成的构造方法
        super(message);
    }
}
class Triangle {
    double side1;
    double side2;
    double side3;
    public Triangle() {
    }
    public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
        if (side1 + side2 > side3 && side1 + side3 > side2 && side2 + side3 > side1) {
            this.side1 = side1;
            this.side2 = side2;
            this.side3 = side3;
        } else {
            throw new IllegalTriangleException("Invalid: " + side1 + "," + side2 + "," + side3);
        }
    }
    @Override
    public String toString() {
        return "Triangle [side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + "]";
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()) {
            double s1 = input.nextDouble();
            double s2 = input.nextDouble();
            double s3 = input.nextDouble();
            try {
                Triangle t = new Triangle(s1, s2, s3);
                System.out.println(t.toString());
            } catch (IllegalTriangleException ex) {
                System.out.println(ex.getMessage());
            }
        }
    }
}

 

注意：

  1. 如果继承的是运行时异常/非受查异常，那么在使用的时候无需额外处理，当然可以try-catch捕获，也可以继续throws向上抛，方便后续捕捉异常（但一般不这么做）
  2. 如果继承的是检查异常/编译时异常/受查异常，那么使用的时候需要try-catch捕获或者throws向上抛 
TheMythWS
关注
  • 24
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
【总结】常见Java故障案例
一寒惊鸿
06-22 2万+
原文 http://dbaplus.cn/news-21-173-1.html 目录 HotSpot常识 Java故障排查方法论 Java故障案例分析 Part 1 HotSpot常识 HotSpot是目前最常见的开源JVM（GPL协议），用来运行Java应用和applet，本次讨论基本都是基于这一软件来进行的。
Java故障案例分析第一期：父子任务使用不当线程池死锁
最新发布
hengyoush的博客
01-31 1165
在Java多线程编程中，线程池是提高性能和资源利用率的常用工具。然而，当父子任务使用同一线程池时，可能导致潜在的死锁问题。本文将深入分析一个实际案例，阐述为何这种设计可能引发死锁，以及如何排查这类问题。
解析Java的迭代器中的fast
wb1597063760的博客
07-21 107
如果开发者在使用时没有注意，将非线程安全的集合类用在了并发的场景下，比如线程A获取了ArrayList的iterator,然后线程B通过调用ArrayList.add()修改了ArrayList的数据，此时就有可能会抛出ConcurrentModificationException，注意，这里是有可能。nono，举个最简单的例子，线程A获取了一个集合类的Iterator,线程B调用了集合类的add(),在add()还没有执行到modCount++时，线程A获取执行，并执行结束。但是这个东西意义有多大呢？
第七章《Java的异常处理》第3节：异常的嵌套处理
穆哥学堂--Java学习园地
11-25 1333
上文列举的所有例子中，try-catch-finally的结构都是单层的，没有出现嵌套现象。实际上，try-catch-finally结构也是可以嵌套的，也就是说：一个try-catch-finally组合结构完全可以出现在另一个try块、catch块和finally块中。嵌套书写try-catch-finally的原因很多，例如有时候在处理异常的过程中又会产生新的异常，这时就需要在处理异常的catch块中再次用try-catch结构对异常进行处理。
JAVA超详细：异常类型及处理（含实例）
m0_51783792的博客
04-08 6144
异常的产生 Java 程序运行期间出现了一个错误。这个错误可能是由于文件包含了错误信息，或者网络连接出现问题造成的，也有可能是因为使用无效的数组下标， 或者试图使用一个没有被赋值的对象引用而造成的。此时用户希望： 返回到一种安全状态，并能够让用户执行一些其他的命令 允许用户保存所有操作的结果，并以妥善的方式终止程序 常见的错误有这几种类型： 用户输入的错误 设备错误 物理限制 代码错误 异常的分类 Throwable类 Throwable类是所有异常类的子类，所有的异常..
深度：一文看懂Linux内核！Linux内核架构和工作原理详解
02-23
理解Linux内核最好预备的知识点：懂C语言懂一点操作系统的知识熟悉少量相关算法懂计算机体系结构Linux内核的特点：结合了unix操作系统的一些基础概念Linux内核的任务：1.从技术层面讲，内核是硬件与软
干货：一文看懂网络爬虫实现原理与技术
02-23
首先我们来看通用网络爬虫的实现原理。通用网络爬虫的实现原理及过程可以简要概括如下（见图3-1）。获取初始的URL。初始的URL地址可以由用户人为地指定，也可以由用户指定的某个或某几个初始爬取网页决定。根据初始...
一文看懂EMC防护器件之TVS
01-20
TVS（TRANSIENT VOLTAGE SUPPRESSOR）或称瞬变电压抑制二极管是在稳压管工艺基础上发展起来的一种新产品。其电路符号和普通稳压二极管相同，外形也...如果单就这个曲线来看,TVS管和普通稳压管的击穿特性没有什么区别，
一文搞懂全链路监控：方案概述与比较
01-27
全链路监控是一种针对复杂分布式系统进行性能和故障排查的重要工具。随着微服务架构的广泛应用，服务被拆分成多个独立的模块，导致一次用户请求可能涉及多个服务交互。在这种背景下，全链路监控应运而生，以帮助理解...
java 嵌套异常_java异常的嵌套和级联
weixin_39929723的博客
02-12 202
一、分开捕获或者嵌套使用我们先看看下面这段代码：public classCal {public int div(int a, intb) {int result = a /b;returnresult;}public static voidmain(String[] args) {Scanner scanner= newScanner(System.in);int s = 0;int num1 =...
《小平工作日志》java异常中嵌套异常的捕获方法
03-24 188
try{ methodTest.getTest(b); }catch(UnsupportedTokenExceptione){ System.out.println("抛出UnsupportedToken...
Java中如何获得嵌套异常中的真实异常message
u010999809的博客
06-27 5396
一、问题说明 1. 不嵌套的情形，比较简单，直接调e.getMessage()就行 2. 嵌套的情形，如果用到后台框架的话，抛出的异常可能嵌套不止一层，这个数量没办法确定 先从简单的开始，弄嵌套两层的吧 二、解决问题 通过上面的简单分析，我们可以写一个简单的工具方法，来不断去除嵌套Exception的外层包装，拿到最里面真实的异常信息 代码如下： public cla...
java 嵌套异常_java – Spring MVC中的嵌套异常处理
weixin_39570838的博客
02-16 449
我收到以下错误：org.springframework.web.util.NestedServletException: Request processing failed; nested exception is java.lang.NullPointerException为了在控制器中处理这个问题,我使用了以下代码：@ExceptionHandler(NestedServletExceptio...
java中多层Exception异常传递及处理浅谈
weixin_42653621的博客
09-07 8260
 JAVA中异常处理是我们经常接触的，很多时候，我们在排查日志的时候都发现，一个很复杂的函数里面，突然间中断了，从日志打印的堆栈信息中，又很难发现真正的问题所在，因为很多时候异常被掩盖了。 举一个最简单的例子，例如： public void testThrowFileEx() throws FileNotFoundException{ throw new FileNotFoundExc...
Java多层嵌套异常处理的基本流程
weixin_30691871的博客
11-11 764
Java多层嵌套异常处理的基本流程 异常是程序中的一些错误，但并不是所有的错误都是异常，错误有时候是可以避免的。异常的对象有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。二是程序员...
Java学习笔记44：异常的嵌套和级联，异常捕获多个如何处理？
qq_30242987的博客
02-22 1653
一、分开捕获或者嵌套使用 我们先看看下面这段代码： public class Cal { public int div(int a, int b) { int result = a / b; return result; } public static void main(String[] args) { Scanner ...
Java多层嵌套异常处理顺序
Fire_Sky_Ho的博客
02-03 744
try { System.out.println("正常执行A"); try { int i=5/0; } catch (Exception e) { System.out.println("内层异常"); throw new RuntimeException("内层异常"); } Syste.
Java代码编写常见问题分析一
肖永威的专栏
11-11 1148
如下所示例代码：         public static String getUserDnsByUserIds(String userIds, String appId, String tenantId) {         //按";"对字符串进行截取         String[] ids = userIds.split(";");         StringBuffer sbf =
一文看懂linux内核
06-08
抱歉，我并不是一个人类，无法真正理解“一文看懂linux内核”的含义。不过，我可以为您提供一些有关学习Linux内核的资源和建议。 首先，了解Linux内核需要具备一定的计算机科学和操作系统基础知识。如果您已经有这方面的基础，可以考虑阅读一些经典的Linux内核书籍，如《深入理解Linux内核》和《Linux内核源代码情景分析》等。 此外，您可以参考一些在线教程和文档，如Linux内核文档（https://www.kernel.org/doc/html/latest/），Linux内核新手指南（https://kernelnewbies.org/），以及一些开源社区的讨论和资源（如GitHub上的Linux内核代码库）。 最后，您可以尝试自己编译和调试Linux内核，以加深对其结构和工作原理的理解。 希望以上建议对您有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TheMythWS

你的鼓励，我的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值