java异常处理(Try Catch Finally)

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量79 收藏
点赞数
文章标签： java 开发工具
原文链接：https://segmentfault.com/a/1190000004681136
版权

一 前言

java异常处理大家都不陌生，总的来说有下面两点：

1.抛出异常:throw exception

class SimpleException{
    public void a() throws Exception{
        throw new Exception();
    };
}

2.捕获异常：

public class MyException {
    public static void main(String[] args){
        MyException e = new MyException();
        SimpleException se = new SimpleException();
        try {
            se.a();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
}

class SimpleException{
    public void a() throws Exception{
        throw new Exception();
    };
｝

本文将在此基础上，更加深入的谈一些细节问题。

二 自定义异常类

java语言为我们提供了很多异常类，但是有时候我们为了写代码的方便还是要自定义的去创造异常类：

class SimpleException extends Exception {};

创建好之后我们可以使用try catch捕获它：

public class MyException {
    public static void main(String[] args){
        MyException e = new MyException();
        try {
            e.a();
        } catch (SimpleException e1) {
            e1.printStackTrace();
        }
    }
    
    public void a() throws SimpleException{
        throw new SimpleException();
    }
}

class SimpleException extends Exception {};

我们在MyException中定义了一个方法a()，让它抛出SimpleException异常，然后我们在main()中调用这个方法，并使用try catch捕获了这个异常：

SimpleException
    at MyException.a(MyException.java:15)
    at MyException.main(MyException.java:8)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

Process finished with exit code 0

编译执行后的结果，主要看前三行就行了。这里着重说明几点：
1.抛出异常类型的指定：(exception specification)
当我们需要在一个方法中抛出一个异常时，我们使用throw后加某异常类的实例，程序会在此向客户端程序（调用这段代码的程序）抛出对应异常并在此退出（相当于return）。另外需要注意的是，我们必须在定义该方法的时候指明异常类型，比如下面这段代码会抛出SimpleException异常

 public void a() throws SimpleException

2.抛出多个异常：

    public void a() throws SimpleException,AException,BException{
        throw new SimpleException();
        
    }

不同的异常类之间用逗号隔开即可，在这种情况下我们不必须throw每个异常类的实例（），但是客户端代码必须要catch到每个异常类：

public class MyException {
    public static void main(String[] args){
        MyException e = new MyException();
        try {
            e.a();
        } catch (SimpleException e1) {
            e1.printStackTrace();
        } catch (BException e1) {
            e1.printStackTrace();
        } catch (AException e1) {
            e1.printStackTrace();
        }
    }

    public void a() throws SimpleException,AException,BException{
        throw new SimpleException();
        
    }
}



class SimpleException extends Exception {};
class AException extends Exception{}
class BException extends Exception{}

三 stack trace

无论是抛出异常，或者是捕获处理异常，我们的目的是为了写出更健壮的程序，这很大程度上依赖于java异常机制给我们提供的异常信息，而它的载体就是stack trace。
前面的代码中我们直接使用printStackTrace()打印出异常信息，其实我们还可以使用getStackTrace()方法来获取StackTraceElement型的集合，如果你手头有IDEA的话，你可以先搜索出StackTraceElement类，可以发现它实现了接口Serializable ，再看看它的类描述：

/**
 * An element in a stack trace, as returned by {@link
 * Throwable#getStackTrace()}.  Each element represents a single stack frame.
 * All stack frames except for the one at the top of the stack represent
 * a method invocation.  The frame at the top of the stack represents the
 * execution point at which the stack trace was generated.  Typically,
 * this is the point at which the throwable corresponding to the stack trace
 * was created.
 *
 * @since  1.4
 * @author Josh Bloch
 */

讲的很清楚，这个类的每个实例都是stack trace的一个元素，代表着一个stack frame，stack trace是由getStackTrace()方法返回的。后边的我试着翻译了几遍，都觉得不好，还是直接上代码才能说清楚：

public class MyException {
    public static void main(String[] args){
        MyException e = new MyException();
        e.a();

    public void a(){
        try {
            throw new Exception();
        } catch (Exception e) {
            StackTraceElement[] ste = e.getStackTrace();
            System.out.println(ste.length);

        }
    }
}

我们定义了方法a，让它抛出Exception异常的同时捕获它，然后我们通过getStackTrace()方法得到一个StackTraceElement型的数组，并打印出数组的长度：

7

Process finished with exit code 0

我们把代码稍微改一下，不在a中捕获异常了，我们重新定义一个方法b，让它在调用a的同时将异常捕获：

public class MyException {
    public static void main(String[] args){
        MyException e = new MyException();
        e.b();
    }

    public void b(){
        try {
            a();
        } catch (Exception e) {
            StackTraceElement[] ste = e.getStackTrace();
            System.out.println(ste.length);
        }
    }

    public void a() throws Exception{
        throw new Exception();
    }
}

结果如下：

8

Process finished with exit code 0

别急，我们再来看点有趣的：

public class MyException {
    public static void main(String[] args){
        MyException exception = new MyException();
        try {
            exception.c();
        } catch (Exception e) {
            StackTraceElement[] ste = e.getStackTrace();
            System.out.println(ste.length);
            System.out.println("---------------------------------------------------------------");
            for (StackTraceElement s : e.getStackTrace()){
                System.out.println(s.getClassName()+":method "+s.getMethodName()+" at line"+s.getLineNumber());
            }
            System.out.println("---------------------------------------------------------------");

        }

    }

 public void c() throws Exception{
        try {
            a();
        }catch (Exception e){
            throw e;
        }
    }

    public void a() throws Exception{
        throw new Exception();
    }
}

下面是结果：

8
---------------------------------------------------------------
MyException:method a at line43
MyException:method c at line39
MyException:method main at line9
sun.reflect.NativeMethodAccessorImpl:method invoke0 at line-2
sun.reflect.NativeMethodAccessorImpl:method invoke at line57
sun.reflect.DelegatingMethodAccessorImpl:method invoke at line43
java.lang.reflect.Method:method invoke at line606
com.intellij.rt.execution.application.AppMain:method main at line144
---------------------------------------------------------------

Process finished with exit code 0

也就是说，getStackTrace()返回一个栈，它包含从调用者(main())到初始抛出异常者(a())的一些基本信息 ,在上面的代码中，我们在c方法中调用a方法时捕获异常并通过throws将其再次抛出(rethrow)，调用c方法的方法可以捕获并处理异常，也可以选择继续抛出让更高层次的调用者（靠近栈底）处理。rethrow虽然很方便，但存在着一些问题，我们看下面这段代码：

public class MyException {
    public static void main(String[] args){
        MyException exception = new MyException();
        try {
            exception.c();
        } catch (Exception e) {
            e.printStackTrace(System.out);
        }

    }

    public void c() throws Exception{
        try {
            a();
        }catch (Exception e){
            throw e;
        }
    }

    public void a() throws Exception{

        throw new Exception("Exception from a()");
    }
}

java.lang.Exception: Exception from a()
    at MyException.a(MyException.java:40)
    at MyException.c(MyException.java:30)
    at MyException.main(MyException.java:21)

我们在c中重新抛出e，在main中使用 e.printStackTrace()打印出来，可以看到打印出来stack trace还是属于a的，如果我们想把stack trace变成c的可以这么写：

public class MyException {
    public static void main(String[] args){
        MyException exception = new MyException();

        try {
            exception.c();
        } catch (Exception e) {
            e.printStackTrace(System.out);
        }

    }

    public void c() throws Exception{
        try {
            a();
        }catch (Exception e){
//            throw e;
            throw (Exception)e.fillInStackTrace();
        }
    }

    public void a() throws Exception{

        throw new Exception("Exception from a()");
    }
}
java.lang.Exception: Exception from a()
    at MyException.c(MyException.java:22)
    at MyException.main(MyException.java:10)

四 异常链 Exception chaining

先来看一个场景：

public class TestException {
    public static void main(String[] args){
        TestException testException = new TestException();
        try {
            testException.c();
        } catch (CException e) {
            e.printStackTrace();
        }
    }

    public void a() throws AException{
        AException aException = new AException("this is a exception");
        throw  aException;
    }

    public void b() throws BException{
        try {
            a();
        } catch (AException e) {
            throw new BException("this is b exception");
        }
    }

    public void c() throws CException{
        try {
            b();
        } catch (BException e) {
            throw new CException("this is c exception");
        }
    }
}

class AException extends Exception{
    public AException(String msg){
        super(msg);
    }
}

class BException extends Exception{
    public BException(String msg){
        super(msg);
    }
}

class CException extends Exception{
    public CException(String msg){
        super(msg);
    }
}

创建了三个异常类AException、BException、CException，然后在a()中抛出AException，在b()中捕获AException并抛出BException，最后在c()中捕获BException并抛出CException，结果打印如下：

CException: this is c exception
    at TestException.c(TestException.java:31)
    at TestException.main(TestException.java:8)

好，我们只看到了CException的信息，AException，BException的异常信息已丢失，这时候异常链的作用就出来了，看代码：

public class TestException {
    public static void main(String[] args){
        TestException testException = new TestException();
        try {
            testException.c();
        } catch (CException e) {
            e.printStackTrace();
        }
    }

    public void a() throws AException{
        AException aException = new AException("this is a exception");
        throw  aException;
    }

    public void b() throws BException{
        try {
            a();
        } catch (AException e) {
//            throw new BException("this is b exception");
            BException bException = new BException("this is b exception");
            bException.initCause(e);
            throw bException;
        }
    }

    public void c() throws CException{
        try {
            b();
        } catch (BException e) {
//            throw new CException("this is c exception");
            CException cException = new CException("this is c exception");
            cException.initCause(e);
            throw cException;
        }
    }
}

class AException extends Exception{
    public AException(String msg){
        super(msg);
    }
}

class BException extends Exception{
    public BException(String msg){
        super(msg);
    }
}

class CException extends Exception{
    public CException(String msg){
        super(msg);
    }
}

我们用initCause()方法将异常信息给串联了起来，结果如下：

CException: this is c exception
    at TestException.c(TestException.java:35)
    at TestException.main(TestException.java:8)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
Caused by: BException: this is b exception
    at TestException.b(TestException.java:24)
    at TestException.c(TestException.java:32)
    ... 6 more
Caused by: AException: this is a exception
    at TestException.a(TestException.java:15)
    at TestException.b(TestException.java:21)
    ... 7 more

Process finished with exit code 0

五 后记

其实关于java异常处理还有很多需要探讨的地方，但是由于我经验有限，还不能体会的太深刻，最常用的也就是

try {
            ...
        }catch (Exception e){
           ... 
        }finally {
          //不管异常会不会被捕捉或者处理都会执行的代码，如关闭IO操作 
        }

但是无论如何我们还是要感谢java给我们提供的异常机制，它好似一个长者，时不时给我们指引道路，也让我们在编码的时候没有那么无聊：）

我的微信号是aristark，欢迎交流指正！

weixin_34233679
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java异常处理之try...catch...finally详解
sdr_zd的博客
07-17 3715
异常处理机制已经成为判断一门编程语言是否成熟的标准之一，其对代码的健壮性有很大影响。一直以来异常处理使用不是很得心应手，今天对异常进行了较为深入的学习，这篇主要是对try…catch…finally的一个总结。一.java继承体系    Java语言为异常处理提供了丰富的异常类，这些类之间有严格的继承关系。如图： 从图中我们可以看出，所有的类都是继承于Throwable这个父类，java将所有
Java异常处理 try catch finally 多重catch 异常分类处理
SKPrimin的博客
08-03 2123
Java异常处理 try catch finally 多重catch 异常分类处理 输入两个数进行求商 使用if-else语句实现实现处理异常 import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入第一个数：");
java try-- catch（异常捕获）
weixin_63215361的博客
05-08 1117
【代码】java try-- catch（异常捕获）
[java进阶]——异常详解，try catch捕获异常，抛出异常
Panci_的博客
10-22 3919
try-catch的执行原理，什么是编译异常，什么是运行异常，请举例finally关键字的作用throw与throws的区别。自定义异常的作用，有继承关系的catch语句，捕获父类异常一定放到最后
Java 异常处理 try catch
qq_43159578的博客
09-07 4445
对于运行时异常，我们不要用try...catch来捕获处理，而是在程序开发调试阶段，尽量去避免这种异常，一旦发现该异常，正确的做法就会改进程序设计的代码和实现方式，修改程序中的错误，从而避免这种异常。如果每个方法都是简单的抛出异常，那么在方法调用方法的多层嵌套调用中，Java虚拟机会从出现异常的方法代码块中往回找，直到找到处理该异常的代码块为止。异常是程序中的一些错误，有些异常需要做处理，有些则不需要捕获处理，异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。
JAVA——try_catch异常语句
weixin_59881338的博客
03-25 732
1.定义异常类* 2.写继承关系* 3.空参构造* 4.带参构造意义:就是为了让控制台的报错信息更加的见名知意定义：//NameFormat:当前异常的名字（姓名格式错误）//Exception:表示当前类是一个异常类//运行时异常：继承RuntimeException类 ----核心：表示由于参数错误而导致的问题//编译时异常：继承Exception类 ------核心：提醒程序员检查本地信息。
JAVA基础--异常
wzdashuaibi的博客
07-28 1532
异常
Java try catch finally异常处理组合详解
08-19
其工作原理是，在try块中执行可能会抛出异常的语句，然后在catch块中捕获并处理异常。try catch组合的语法结构如下： ```java try { // 可能会抛出异常的语句 } catch (异常类型 e) { // 异常处理语句 } ``` try...
Java异常处理之try...catch...finally详解
08-26
Java异常处理之try...catch...finally详解 Java异常处理机制是判断一门编程语言是否成熟的标准之一，对代码的健壮性有很大影响。Java语言为异常处理提供了丰富的异常类，这些类之间有严格的继承关系。所有的类都是...
简单谈谈java的异常处理(Try Catch Finally)
09-02
本文将深入探讨Java异常处理的关键元素——try、catch和finally，以及如何自定义异常类。 首先，Java中的异常处理基于五个关键字：`try`、`catch`、`finally`、`throw`和`throws`。`try`块用于包含可能会抛出异常的...
Java中异常处理之try和catch代码块的使用
09-03
主要介绍了Java中异常处理之try和catch代码块的使用,是Java入门学习中的基础知识,需要的朋友可以参考下
详解Java异常处理中finally子句的运用
09-03
在Java中，异常处理通过`try-catch-finally`结构实现。当在`try`块中发生异常时，控制权会立即转移到与之匹配的`catch`块，如果没有匹配的`catch`块，则异常会向上冒泡到调用栈中的上一级。而`finally`块则是一个可...
try catch finally的执行顺序深入分析
09-05
在Java、C#、JavaScript等语言中，`try-catch-finally`结构是异常处理的基础。这个结构的执行顺序是固定的，下面我们将深入分析其工作原理。 首先，程序会尝试执行`try`块中的代码。`try`块的作用是包含可能抛出...
【JavaSE】 try-catch 异常处理
兮动人
03-15 5886
9. try-catch 异常处理 9.1 try-catch 方式处理异常说明 Java提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用 于处理try块中发生的异常。可以根据需要在程序中有多个try…catch块。 基本语法 try { //可疑代码 //将异常生成对应的异常对象，传递给catch块 }catch(异常){ //对异常的处理 } //如果没有finally，语法是可以通过 9.2 try-catch 方式处理异常-快速入门 ...
Java Exception - 使用try-catch捕获异常
热门推荐
你今天真好看呀
05-05 1万+
文章目录1. 异常处理机制2. 使用try...catch捕获异常3. 先捕获小异常，再捕获大异常4. 访问异常信息5. 使用finally回收资源 1. 异常处理机制 Java的异常处理机制可以让程序具有极好的容错性，让程序更加健壮。当程序运行出现意外情形时，系统会自动生成一个Exception对象来通知程序，从而实现将“业务功能实现代码”和“错误处理代码”分离，提供更好的可读性。 2. 使用try…catch捕获异常 如果程序可以顺利完成，那就“一切正常”，把系统的业务实现代码放在try块中定义，所有的
异常的处理
weixin_39371622的博客
12-01 661
Java异常处理的五个关键字：try、catch、finally、throw、throws 2.1 抛出异常throw 在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。 在java中，提供了一个t...
Java——try-catch异常处理
qq_59708493的博客
05-27 4877
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
【Java】异常 try-catch throw 详解
这很宇航的博客
06-05 2319
【Java】异常 try-catch throw 详解
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1220
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
java异常处理trycatch捕获
06-19
它使用`try-catch`块来控制程序流程，以便在遇到错误时不会立即终止程序，而是提供了一种策略来处理这些异常。 1. **try块**：这是包含可能会抛出异常的代码部分。如果try块中的代码执行过程中发生了异常，那么程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值