Java 异常的捕获与处理详解（一）

最新推荐文章于 2024-09-04 08:30:00 发布
最新推荐文章于 2024-09-04 08:30:00 发布
阅读量514 收藏 3
点赞数
分类专栏： Java

一、异常的产生

异常是程序之中导致程序中断的一种指令流，异常一旦出现并且没有进行合理处理的话，那么程序就将中断执行。 
下面，通过两个程序来进行异常产生问题的对比。 
（1）不产生异常的程序：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        int result = 10 / 2;
        System.out.println("2、除法计算结果：" + result);
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

运行结果：

1、除法计算开始。
2、除法计算结果：5
3、除法计算结束。
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

（2）产生异常的程序

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        int result = 10 / 0; // 会出现错误
        System.out.println("2、除法计算结果：" + result);
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

运行结果：

1、除法计算开始。Exception in thread "main" 
java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:4)

 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

一旦产生异常，我们发现产生异常的语句以及之后的语句将不再执行，默认情况下是进行异常信息的输出，而后自动结束程序的执行。

现在，我们要做的是：即使程序出现了异常，也要让程序正确的执行完毕。

二、异常的处理

如果希望程序出现异常之后程序依然可以正常的完成的话，那么就可以使用如下的格式进行异常的处理：

try {
         可能出现异常的语句 ;
} [ catch (异常类型 异常对象) {
         处理异常 ;
} catch (异常类型 异常对象) {
         处理异常 ;
} ... ] [finally {
         不管是否出现异常，都执行此代码 ;
}]
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

现在，使用以上的操作处理异常处理前面除法于是出现的异常：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            int result = 10 / 0; // 异常
            System.out.println("2、除法计算结果：" + result); // 之前语句有异常，此语句不再执行
        } catch (ArithmeticException e) {
            System.out.println(e); // 异常处理：输出错误信息，java.lang.ArithmeticException:/ by zero
        }
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

运行结果：

1、除法计算开始。
java.lang.ArithmeticException: / by zero
3、除法计算结束。

 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

可以发现，加入了异常处理之后，程序中即使有了异常，程序也可以正常的执行完毕，但是异常处理时的错误输出信息和之前相比，出错的信息不明确了，那么为了让错误的信息更加的完整，一般都会调用printStackTrace()方法进行异常信息的打印，这个方法打印的异常信息是最完整的：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            int result = 10 / 0; // 异常
            System.out.println("2、除法计算结果：" + result); // 之前语句有异常，此语句不再执行
        } catch (ArithmeticException e) {
            e.printStackTrace(); // 异常处理：输出错误信息
        }
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

运行结果：

1、除法计算开始。
java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:5)
3、除法计算结束。
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

此时发现，打印的信息是很完整的。

除了try…catch格式处理异常外，还可以使用try…catch..finally:

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            int result = 10 / 1;
            System.out.println("2、除法计算结果：" + result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出现异常都执行");
        }
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

运行结果：

1、除法计算开始。
2、除法计算结果：10
不管是否出现异常都执行
3、除法计算结束。
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

但是，对于之前的程序又有了问题：现在执行数学计算的两个参数，都是由程序默认提供，那么如果说现在两个计算的参数通过初始化参数传递呢？

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            int x = Integer.parseInt(args[0]); // 接收参数
            int y = Integer.parseInt(args[1]); // 接收参数
            int result = x / y;
            System.out.println("2、除法计算结果：" + result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出现异常都执行");
        }
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

这个时候，数据由外部传送，那么就有可能出现以下几类问题： 
（1）执行时不输入参数（Java TestDemo），ArrayIndexOutOfBoundsException，未处理； 
（2）输入的参数不是数字（java TestDemo a b），NumberFormatException，未处理； 
（3）被除数为0（java TestDemo 10 0），ArithmeticException，已处理。 
可以发现，以上的程序实际上是存在三种异常，而程序之中只能够处理一种，而对于不能处理的异常，发现程序依然会直接中断执行。 
加入多个catch：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            int x = Integer.parseInt(args[0]);
            int y = Integer.parseInt(args[1]);
            int result = x / y;
            System.out.println("2、除法计算结果：" + result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出现异常都执行");
        }
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

现在，程序比之前更健壮了。

三、异常的处理流程

以上已经完成了异常的基本处理，但是所有的异常都像之前那样一条条的判断似乎是一件不可能完成的任务，因为日后肯定会接触到一些不常见的异常信息，那么下面就必须首先研究异常的流程和结构。

先查看两个异常类的继承结构： 
（1）ArithmeticException：

java.lang.Object
    |- java.lang.Throwable
         |- java.lang.Exception
              |- java.lang.RuntimeException
                 |- java.lang.ArithmeticException
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

（2）ArrayIndexOutOfBoundsException：

java.lang.Object
   |- java.lang.Throwable
      |- java.lang.Exception
         |- java.lang.RuntimeException
             |- java.lang.IndexOutOfBoundsException
                |-java.lang.ArrayIndexOutOfBoundsException
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

可以发现，所有的异常类型最高的继承类是Throwable，Throwable下有两个子类： 
（1）Error：指的是JVM错误，这个时候的程序并没有执行，无法处理； 
（2）Exception：指的是程序之中出现的错误信息，可以进行异常处理。

通过继承关系可以发现，在进行日后异常处理的时候是以Exception为主，并且可以形成以下的异常处理流程：

11

（1）如果程序中产生了异常，那么JVM根据异常的类型，实例化一个指定异常类的对象；

（2）如果这时程序中没有任何的异常处理操作，则这个异常类的实例化对象将交给JVM进行处理，而JVM的默认处理方式就是进行异常信息的输出，而后中断程序执行；

（3）如果程序中存在了异常处理，则会由try语句捕获产生的异常类对象；

（4）与try之后的每一个catch进行匹配，如果匹配成功，则使用指定的catch进行处理，如果没有匹配成功，则向后面的catch继续匹配，如果没有任何的catch匹配成功，则这个时候将交给JVM执行默认处理；

（5）不管是否有异常都会执行finally程序，如果此时没有异常，执行完finally，则会继续执行程序之中的其他代码，如果此时有异常没有能够处理（没有一个catch可以满足），那么也会执行finally，但是执行完finally之后，将默认交给JVM进行异常的信息输出，并且程序中断。

通过以上的分析可以发现，实际上catch捕获异常类型的操作，就和方法接收参数是一样的，那么按照之前所学习过的对象多态性来讲，所有的异常类都是Exception的子类，那么这个时候，实际上所有的异常都可以使用Exception进行接收：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法计算开始。");
        try {
            int x = Integer.parseInt(args[0]);
            int y = Integer.parseInt(args[1]);
            int result = x / y;
            System.out.println("2、除法计算结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出现异常都执行");
        }
        System.out.println("3、除法计算结束。");
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

这时应该可以感受到异常处理所带来的好处了。但是这种操作也存在一种问题：如果在一些异常处理要求严格的项目之中，异常必须分别处理，如果现在异常的处理要求不是很严格，直接编写Exception就足够了。

未完待续。。。

fishineye
关注
专栏目录
java从异常里获取入参信息_java – 使用Spring AOP处理异常时获取传递给方法的参数的值...
weixin_34662764的博客
03-02 855
在我的方面类的方法中,我想获取参数的值和参数的名称.如果我没有得到名称仍然可以,但我需要获取传递的参数的值是否可能？(ptCut表达式没有问题,该方法被调用我用sysouts检查)我的Aspect方法是这样的：public void excpetionHappened(Exception e) {// Log the exception// log the name of the method n...
详解Java中多线程异常捕获Runnable的实现
08-29
Java 多线程异常捕获 Runnable 实现详解 Java 多线程编程是一个非常重要的知识点，然而在多线程编程中，异常捕获是一个很大的挑战。本文主要介绍了 Java 中多线程异常捕获 Runnable 的实现，包括背景、工具、思路、...
【Java基础教程】（十九）异常捕获处理篇 · 上：异常的概念及处理流程解析，try、catch、finally、throws、throw的作用，RuntimeException类介绍~
Technology changes the world of life
07-19 1907
异常的概念及处理流程解析，try、catch、finally、throws、throw的作用，RuntimeException类介绍~
Java异常处理-捕获异常
最新发布
Flying_Fish_roe的博客
09-04 1016
在Java中，异常处理是一种用于处理可能发生的错误或异常的机制。Java的异常处理机制主要包括try、catch和finally块。使用try块：try块用于包含可能会抛出异常的代码。在try块中，如果发生异常，程序将会跳转到对应的catch块。使用catch块：catch块用于捕获try块中抛出的异常。catch块包含了对异常的处理逻辑，可以根据不同的异常类型进行不同的处理。一个try块可以有多个catch块，用于处理不同的异常类型。
JAVA的异常捕捉和处理流程_Java 异常处理 之 捕获处理流程
weixin_28964839的博客
02-26 123
package com.exception2;/** 注意:1. 当异常发生的时候,程序会终止,其后面的代码不会执行.2. 异常分为编译时异常和运行期异常编译期异常必须用 try{}catch{}捕获,运行期异常可以不捕获编译期异常从 Exception 继承, 运行期异常从RuntimeException 继承异常的处理流程注意:1. try{}catch{} 代码块里的局部变量, 不能在其外...
Java异常的处理和捕获以及相关概念（异常构架，简介）
YSY02的博客
03-10 233
Java异常架构与异常关键字 Java异常简介 Java异常是Java提供的一种识别及响应错误的一致性机制。 Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。在有效使用异常的情况下，异常能清晰的回答what, where, why这3个问题：异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪”抛出，异常信息回答了“为什么”会抛出。 Java异...
Java异常分类及统一处理详解
09-02
Java异常处理是编程中至关重要的一个环节，它确保了程序在遇到错误情况时能够优雅地失败，而不是突然崩溃。异常分为两大类：检查异常（Checked Exceptions）和非检查异常（Unchecked Exceptions）。检查异常是那些在...
JVM处理未捕获异常的方法详解
08-26
在Java编程中，JVM（Java虚拟机）对于未捕获异常的处理是至关重要的，因为这直接影响到程序的稳定性和错误处理能力。未捕获异常通常是指在方法体内没有被try-catch语句块捕获的异常，例如在代码执行过程中抛出的...
Java中的异常和处理机制实例详解
08-26
Throwable类是Java异常类型的顶层父类，任何一个对象只有是Throwable类的实例，它才是一个异常对象，才能被异常处理机制识别。JDK中内建了一些常用的异常类，我们也可以自定义异常。 非检查异常包括Error和...
详解Java Streams 中的异常处理
08-26
Java Streams 中的异常处理详解 Java Streams 中的异常处理是Java 8 中 Stream API 的一个重要方面。Stream API 和 Lambda 是 Java 8 的重要特性，让我们可以使用更具功能性的语法风格。但是在编写代码时，一个更大...
异常的捕获及处理
weixin_30782331的博客
09-14 169
作者：gqk： 　　1、 异常的产生原因及处理格式 　　2、 异常的标准使用方式 　　3、 throw 和 throws 关键字的作用 认识异常：保证程序不会因出现异常而终止，必须对有可能出现异常的代码进行处理 现实生活中的异常： 　　 处理异常：上班的途中遇到异常后，我们可定要对这些异常进行处理，两种方式， 　　一：自己解决 　　二：打电话让让别人解决 在 Ja...
JAVA中的异常处理
weixin_73986007的博客
05-20 1511
异常和异常处理
一次搞懂Java异常处理(超详细!!!)！
weixin_53622554的博客
03-17 9651
Java标准库中提供了非常多表的异常类型，用来表达各种异常情况，然而在真实开发中，这些异常并不能完全满足我们的需求，因为标准库的异常往往表达的是技术层面，而不是业务层面，像账号密码错误这种情况，用标准库的异常就不太合适，所以在开发中我们会自定义异常类型，来表达符合我们业务的异常情况。finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法放入finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
【Java基础篇】Java异常篇
输入技术、输出想法
05-27 1775
java异常篇Java 异常处理Exception 类的层次Java 内置异常类异常方法捕获异常throws/throw 关键字finally关键字声明自定义异常通用异常final、 finally、 finalize 的区别？ Java 异常处理 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛
终于有人把Java异常处理方法给总结出来了，吃透这篇足够
the shy
05-04 2987
这篇文章是我之前学过的基础总结，希望对大家有所帮助！我们在做程序开发时候，都想着把代码写的完美无瑕（不大可能）客户输入的数据格式读取文件是否存在网络是否始终保持通畅我们把这类问题，归结为异常！异常概念：在Java语言中，将程序执行中发生的不正常情况称为异常（异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行）Java中异常分为两类Error：java虚拟机无法解决的严重问题（JVM系统内部错误、资源耗尽），一般没办法编写针对性代码进行处理（处理不了。
Java 常见异常种类
biyesheji1000的专栏
06-17 2329
----------------------------------------------------------------------------------------------------------------------------/>，这样web 服务器解析时就当作一个无主体的标记，随后使用的所有标记都被认为是在这个标记之外的，如又使用了还有就是在使用taglib引入HTML标记库时，你使用的prefix的值不是html。
Java 第27 章 ： 异常的捕获及处理
u012820292的博客
12-10 322
课时116：认识异常对程序的影响 Java语言提供的最为强大的支持在于异常的处理操作上。 认识异常对程序的影响 异常指的是导致程序中断执行的一种指令流。那么下面首先来观察没有异常产生的程序执行结果。 范例：没有异常产生 package cn.mldn; public class JavaDemo { public static void main(String args[]) { System.out.println("【1】***...
Java中常见的十八种异常！
weixin_65403860的博客
06-05 3716
数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化， 依然是空的，所以还需要对每个元素都进行初始化(如果要调用的话)。查看调用的数组或者字符串的下标值是不是超出了数组的范围，一般来说，显示(即直接用常数当下标)调用不太容易出这样的错，但隐式(即用变量表示下标)调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候先查看一下数组的length，以免出现这个异常。当程序在输入的过程中遇到文件或流的结尾时，引发异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值