精华内容
下载资源
问答
  • java 如何捕获数据库底层异常
    2021-01-27 01:26:51

    org.hibernate.exception.ConstraintViolationException:CouldnotexecuteJDBCbatchupdateatorg.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:71)atorg.hib...

    org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update

    at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:71)

    at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)

    at org.junit.internal.runners.JUnit38ClassRunner.run(JUnit38ClassRunner.java:81)

    ……

    ……

    省略

    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)

    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

    Caused by: java.sql.BatchUpdateException: ORA-00001: unique constraint (SI.UK_CN_EN) violated

    ----说明---------------------------------------------------------------------------------------

    我们的项目是SSH2

    我现在只能捕获到HibernateException:Could not execute JDBC batch update

    但是我想要捕获底层异常信息:java.sql.BatchUpdateException: ORA-00001: unique constraint (SI.UK_CN_EN) violated

    请问我如何才能捕捉到数据库底层异常

    展开

    更多相关内容
  • 通常来说,大家都是对Java中的Exception进行捕获和进行相应的处理,有些人说,error就无法捕获了。其实,error也是可以捕获的。Error和Exception都是Throwable的子类。既然可以catch Throwable,那么error也是可以...
  • 自己编写异常类型 ,自定义错误异常进行全局捕捉。实现项目全局的拦截定义输出。。。
  • 主要介绍了java异常处理机制示例(java抛出异常捕获、断言),需要的朋友可以参考下
  • 主要介绍了java捕获异常信息存入txt文件示例,需要的朋友可以参考下
  • 主要大家详细介绍了java实现系统捕获异常发送邮件案例,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 一,异常捕获在上节课我们观察了异常的出现,而且我们异常的第一节课:Java异常处理(观察常见异常)就说了如果程序出现了异常则出现异常之后的代码就不再执行了,相当于中断了程序,如果出现异常之后的代码还能...

    一,异常的捕获

    在上节课我们观察了异常的出现,而且我们异常的第一节课:Java异常处理(观察常见异常)就说了如果程序出现了异常则出现异常之后的代码就不再执行了,相当于中断了程序,如果要出现异常之后的代码还能继续执行,则需要将这个异常捕获处理之后才可以

    DEMO:出现异常的代码

    6c8075d06f40d7c1ae903c7e3b560a1c.png

    此时发现出现数字格式化异常,也就是不能将一个非数字类型的字符串转换成一个整数,导致了后面的代码没有执行,如果要让后面的代码执行需要先捕获处理异常

    异常处理的语法如下:

    7b96d77eb7bac0d48309db2a96d5131c.png

    其中“异常类型”确定了你当前的这个try语句块只能捕获你给定的异常类型以及该异常类型的子类类型。

    DEMO:处理异常

    a41705ca86336d2610e12beb351a7be1.png

    5ece78fedee29d5672bd02a54624a3de.png

    发现了出现异常的之后的代码也执行了,但是没有打印出异常信息,如果打印出异常信息,只需要调用异常对象的“printStackTrace()”

    DEMO:打印出异常信息

    3e80cf8dde753151ca6db709ae1ab914.png

    7976448c87a848df0f6adfda812cb60d.png

    发现了我们在 catch 语句中定义的异常类型是Exception,但是我们try 语句块中出现的异常是“java.lang.NumberFormatException ",那感觉不一样却能捕获,是什么原因呢﹖其实"java.lang.Exception”是“java.lang.NumberFormatException”的父类

    发现了能打印异常信息,同时能执行异常出现之后的代码。其实上以上处理异常的语句还不够完善,因为有这样的需求:要求一段代码不管是否出现异常都必须执行,那么这断代码需要放到finally语句中,于是要在catch 之后加上finally语句。

    DEMO:finally语句

    b11a1be3a8a3fad8b9cdab156b7fd543.png

    d5f6a727f52e98cdebb901ca1a3e18fc.png

    978f8a97f0f6cbafad68ffe3ccc100e8.png

    以上的代码证明了不管是否出现异常finally中的程序都会被执行。

    我们上面分析出现异常的代码之后的程序还会被执行,但是如果这个程序是在try语句块中呢?

    DEMO:如果出现异常代码之后的代码是在try 语句块中

    04a209450f12b29a51606ce59cba11c0.png

    532eeafe0b2556915a1937e4c267b553.png

    72cc69bfe356f878dd421688c26f08f1.png

    如果出现异常之后的程序在try语句块之外则处理了异常就会被执行,

    如果出现异常之后的代码是try语句块之内则不会被执行。

    总结:

    1、出现异常之后的代码如果不做异常处理或者没有捕获到则不会被执行,也就是终止了程序

    2、如果处理了异常:

    I-在try语句块之外的程序会被执行

    |-如果是在try语句块之内则就算异常被处理完毕出现异常后面的代码还是不会被执行

    3、finally语句中的代码不管是否出现异常、不管是否处理了异常都会被执行。

    有完整的Java初级,高级对应的学习路线和资料!专注于java开发。分享java基础、原理性知识、JavaWeb实战、spring全家桶、设计模式、分布式及面试资料、开源项目,助力开发者成长!

    欢迎关注微信公众号:码邦主

    内容来源于网络如有侵权请私信删除

    展开全文
  • java多线程程序中所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉。但是无法避免的是unchecked exception,也就是RuntimeException,当抛出异常时子线程...
  • 主要介绍了详解Java中多线程异常捕获Runnable的实现的相关资料,希望通过本文能帮助到大家,让大家理解掌握这样的知识,需要的朋友可以参考下
  • java try…catch捕获异常的实例 java try…catch捕获异常的实例
  • JAVA异常捕获

    2014-09-22 13:37:42
    JAVA异常捕获,课程笔记,毕向东的课程视频。
  • Java异常捕获及处理

    千次阅读 2021-02-06 21:49:26
    导语学完异常捕获及处理就懂的情书。// 情书// 理解包容全部的你try {we.together(time); // 和你在一起的时间} catch(Exception e) { // 接收到所有在一起的问题i.understandYou(); // 我理解你i.containYou(); /...

    导语

    学完异常的捕获及处理就懂的情书。

    // 情书

    // 理解包容全部的你

    try {

    we.together(time); // 和你在一起的时间

    } catch(Exception e) { // 接收到所有在一起的问题

    i.understandYou(); // 我理解你

    i.containYou(); // 我包容你

    } finally {

    we.love++; // 不管发生什么,我们的爱都会越来越多

    }

    主要内容

    异常的产生以及对于程序的影响

    异常处理的格式

    异常的处理流程(核心)

    throw、throws关键字的使用

    异常处理的使用标准(重要代码模型)

    自定义异常

    具体内容

    异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。所谓异常处理,就是指程序在出现问题时依然可以正确的执行完。

    异常是Java的一个重大特色,合理的使用异常处理,可以让我们程序更加的健壮。

    异常的产生

    异常是导致程序中断执行的一种指令流,异常一旦出现并且没有合理处理的话,那么程序就会将中断执行。

    范例:产生异常的代码

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    System.out.println("2、除法计算。" + (10 / 0)); // 除数不能为0,所以会产生异常

    System.out.println("3、除法计算结束。");

    }

    }

    会出现异常:

    java.lang.ArithmeticException

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

    我们要做的事情是:即使出现了异常,那么也应该让程序正确的执行完毕。

    异常的处理

    如果想要进行异常的处理,在Java之中提供了三个关键字:try、catch、finally,而这三个关键字的使用语法如下所示。

    try{

    // 有可能出现异常的语句

    } [catch(异常类型 对象) {

    // 处理异常

    } catch(异常类型 对象) {

    // 处理异常

    } catch(异常类型 对象) {

    // 处理异常

    } ... ] [finally {

    // 不管是否出现异常,都执行的统一代码

    }]

    范例:应用异常的处理

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    System.out.println("2、除法计算:" + (10 / 0)); // 除数不能为0,所以会产生异常

    System.out.println("############");

    } catch(ArithmeticException e) {

    System.out.println("******出现异常******");

    }

    System.out.println("3、除法计算结束。");

    }

    }

    输出结果:

    1、除法计算开始。

    ******出现异常******

    3、除法计算结束。

    由于使用了异常处理,这样即使程序中出现了异常,发现也可以正常的执行完毕。

    出现的异常的目的是为了解决异常,所以为了能够进行异常的处理,可以使用异常类中提供的printStackTrace()方法,进行异常信息的完整输出。

    范例:使用printStackTrace()方法

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    System.out.println("2、除法计算:" + (10 / 0));

    } catch(ArithmeticException e) {

    e.printStackTrace();

    }

    System.out.println("3、除法计算结束。");

    }

    }

    输出结果:

    1、除法计算开始。

    java.lang.ArithmeticException: / by zero at TestDemo.main(TestDemo.java:5)

    3、除法计算结束。

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

    范例:使用finally

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    System.out.println("2、除法计算:" + (10 / 0));

    } catch(ArithmeticException e) {

    System.out.println("******出现异常******");

    } finally {

    System.out.println("###不管是否出现异常我都执行!###");

    }

    System.out.println("3、除法计算结束。");

    }

    }

    输出结果:

    1、除法计算开始。

    ******出现异常******

    ###不管是否出现异常我都执行!###

    3、除法计算结束。

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    System.out.println("2、除法计算:" + (10 / 2));

    } catch(ArithmeticException e) {

    System.out.println("******出现异常******");

    } finally {

    System.out.println("###不管是否出现异常我都执行!###");

    }

    System.out.println("3、除法计算结束。");

    }

    }

    输出结果:

    1、除法计算开始。

    2、除法计算:5

    ###不管是否出现异常我都执行!###

    3、除法计算结束。

    在异常捕获的时候发现,一个try语句后同可以跟着多个catch语句。

    范例:观察程序

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    int x = Integer.parseInt(args[0]);

    int y = Integer.parseInt(args[1]);

    System.out.println("2、除法计算:" + (x / y));

    } catch(ArithmeticException e) {

    e.printStackTrace();

    } finally {

    System.out.println("###不管是否出现异常我都执行!###");

    }

    System.out.println("3、除法计算结束。");

    }

    }

    以上的程序将由用户输入操作数据,于是可能存在有如下的情况出现:

    用户执行的时候不输入参数(java.lang.ArrayIndexOutOfBoundsException数组越界)。

    用户输入的参数不是数字(java.lang.NumberFormatException数字格式)。

    被除数为0(java.lang.ArithmeticException计算)。

    范例:加入多个catch

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    int x = Integer.parseInt(args[0]);

    int y = Integer.parseInt(args[1]);

    System.out.println("2、除法计算:" + (x / y));

    } catch(ArrayIndexOutOfBoundsException e) {

    e.printStackTrace();

    } catch(NumberFormatException e) {

    e.printStackTrace();

    } catch(ArithmeticException e) {

    e.printStackTrace();

    } finally {

    System.out.println("###不管是否出现异常我都执行!###");

    }

    System.out.println("3、除法计算结束。");

    }

    }

    程序现在的确很健壮,所有可能出现的异常都处理完了。

    以上的异常都已经知道了,还让它出现,这绝对是技术问题。

    异常的处理流程(核心)

    通过以上的分析应该已经掌握了异常的处理格式了,但是遗憾的是,以上的操作并不是最好的异常处理方法,所以我们必须清楚整个Java中异常的处理流程。

    首先来观察两个异常类的继承结构:

    ArithmeticException

    NumberFormatException

    java.lang.Object

    --java.lang.Throwable

    ----java.lang.Exception

    ------java.lang.RutimeException

    --------java.lang.ArithmeticException

    java.lang.Object

    --java.lang.Throwable

    ----java.lang.Exception

    ------java.lang.RuntimeException

    --------java.lang.IllegalArgumentException

    ----------java.lang.NumberFormatException

    经过异常类的观察可以发现所有的异常类都是Throwable的子类。而在Throwable下有两个子类:

    Error:指的是JVM错误,指此时的程序还没有执行,如果没有执行用户无法处理。

    Exception:指的是程序运行中产生的异常,用户可以处理。

    也就是所谓的异常处理指的就是所有Exception以及它的子类异常。

    8260f6d52f23

    异常处理流程

    异常处理流程:

    1、当程序在运行的过程之中出现了异常后,那么会由JVM自动根据异常的类型实例化一个与之类型匹配的异常类对象(此处用户不用去关心new,由系统自动负责处理)。

    2、产生了异常对象之后会判断当前的语句上是否存在有异常处理,如果现在没有异常处理,那么就交给JVM进行默认的异常处理,处理的方式:输出异常信息,而后结束程序的调用。

    3、如果此时存在有异常的捕获操作,那么会由try语句来捕获产生的异常类实例化对象,而后与try语句之后的每一个catch进行比较,如果现在有符合的捕获类型,则使用当前catch的语句来进行异常的处理,如果不匹配,则向下继续匹配其它的catch。

    4、不管最后异常处理是否能够匹配,那么都要向后执行,如果此时程序中存在有finally语句,那么就先执行finally中的代码,但是执行完毕后需要根据之前的catch匹配结果来决定如何执行,如果之前已经成功的捕获了异常,那么就继续执行,finally之后的代码,如果之前没有成功的捕获异常,那么就将此异常交给JVM默认处理。

    整个过程就好比方法重载一样。根据catch后面的参数类型进行匹配,但是所有Java对象都存在有自动的向上转型的操作支持,也就是说如果要真的匹配类型,简单的做法是匹配Exception就够了。

    范例:使用Exception处理异常

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println("1、除法计算开始。");

    try {

    int x = Integer.parseInt(args[0]);

    int y = Integer.parseInt(args[1]);

    System.out.println("2、除法计算:" + (x / y));

    } catch(Exception e) {

    e.printStackTrace();

    } finally {

    System.out.println("###不管是否出现异常我都执行!###");

    }

    System.out.println("3、除法计算结束。");

    }

    }

    此时所有的异常都使用了Exception进行处理,所以在程序之中不用再去关心到底使用哪一个异常。

    两点说明:

    在编写多个catch捕获异常的时候,捕获范围大的异常一定要放在捕获范围小的异常之后,否则程序编译错误。

    虽然直接捕获Exception比较方便,但是这样也不好,因为所有的异常都会按照同样一种方式进行处理。所以在一些要求严格的项目里面,异常一定要分开处理会更好。

    throws关键字

    throws关键字主要用于方法的声明上,指的是当我们方法之中出现异常后交由被调用处来处理。

    范例:使用throws

    class MyMath {

    // 由于存在有throws,那么就表示此方法里产生的异常交给被调用处处理

    public static int div(int x, int y) throws Exception {

    return x / y;

    }

    }

    调用以上的方法(错误示范)

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println(MyMath.div(10, 2));

    }

    }

    代码改为

    public class TestDemo {

    public static void main(String args[]) {

    try {

    System.out.println(MyMath.div(10, 2));

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    如果调用了具有throws声明的方法之后,那么不管操作是否出现异常,都必须使用try...catch来进行异常的处理。

    在程序之中主方法也属于方法,那么主方法上能否继续使用throws来抛出异常呢?

    public class TestDemo {

    public static void main(String args[]) throws Exception {

    // 表示此异常产生之后会直接通过主方法抛出

    System.out.println(MyMath.div(10, 0));

    }

    }

    在主方法上如果继续抛出了异常,那么这个异常就将交给JVM进行处理,也就是默认处理方法,输出异常信息,而后结束程序调用 。

    主方法上不要加上throws,因为程序如果出错了,也希望可以正常的结束调用。

    throw关键字

    在程序之中可以直接使用throw手工的抛出一个异常类的实例化对象。

    范例:手工抛出异常

    public class TestDemo {

    public static void main(String args[]) {

    throw new Exception("自己定义的异常!");

    }

    }

    编译错误

    错误:未报告的异常错误Exception,必须对其进行捕获或声明以便抛出throw new Exception("自己定义的异常!");

    修改代码

    public class TestDemo {

    public static void main(String args[]) {

    try {

    throw new Exception("自己定义的异常!");

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    执行结果

    java.lang.Exception:自己定义的异常!

    异常肯定应该尽量回避,为什么要自己抛出异常呢?

    throw和throws的区别:

    throw:指的是在方法之中人为抛出一个异常类对象。

    throws:在方法的声明上使用,表示此方法在调用时必须处理异常。

    异常处理标准格式(重要代码模型)

    现在要求定义一个div()方法,要求,这个方法在进行计算之前打印提示信息,在计算结束完毕也打印提示信息,如果在计算之中产生了异常,刚交给被调用处进行处理。

    范例:上面要求

    先写出不出错的情况

    class MyMath {

    public static int div(int x, int y) {

    int result = 0;

    System.out.println("***1、除法计算开始***");

    result = x / y;

    System.out.println("***2、除法计算结束***");

    return result;

    }

    }

    public class TestDemo {

    public static void main(String args[]) {

    System.out.println(MyMath.div(10, 2));

    }

    }

    输出结果:

    ***1、除法计算开始***

    ***2、除法计算结束***

    5

    对于以上给出的除法操作不可能永远都正常的完成,所以应该进行一些合理的处理,首先某个方法出现异常了必须交给被调用处处理,那么应该在方法上使用throws抛出。

    修改代码

    class MyMath {

    // 此时表示div()方法上如果出现了异常交给被调用处处理

    public static int div(int x, int y) throws Exception {

    int result = 0;

    System.out.println("***1、除法计算开始***");

    result = x / y;

    System.out.println("***2、除法计算结束***");

    return result;

    }

    }

    public class TestDemo {

    public static void main(String args[]) {

    try {

    System.out.println(MyMath.div(10, 2));

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    输出结果:

    ***1、除法计算开始***

    ***2、除法计算结束***

    5

    如果代码出错了呢

    class MyMath {

    // 此时表示div()方法上如果出现了异常交给被调用处处理

    public static int div(int x, int y) throws Exception {

    int result = 0;

    System.out.println("***1、除法计算开始***");

    result = x / y;

    System.out.println("***2、除法计算结束***");

    return result;

    }

    }

    public class TestDemo {

    public static void main(String args[]) {

    try {

    System.out.println(MyMath.div(10, 0));

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    输出结果:

    ***1、除法计算开始***

    java.lang.ArithmeticException...

    如果代码出错了呢?程序有些内容就不执行了,这样明显不对。

    修改代码

    class MyMath {

    // 此时表示div()方法上如果出现了异常交给被调用处处理

    public static int div(int x, int y) throws Exception {

    int result = 0;

    System.out.println("***1、除法计算开始***");

    try {

    result = x / y;

    } catch(Exception e) {

    throw e;

    } finally {

    System.out.println("***2、除法计算结束***");

    }

    return result;

    }

    }

    public class TestDemo {

    public static void main(String args[]) {

    try {

    System.out.println(MyMath.div(10, 0));

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    输出结果:

    ***1、除法计算开始***

    ***2、除法计算结束***

    java.lang.ArithmeticException...

    实际上以上的代码还可以缩写(不建议使用)。

    class MyMath {

    // 此时表示div()方法上如果出现了异常交给被调用处处理

    public static int div(int x, int y) throws Exception {

    int result = 0;

    System.out.println("***1、除法计算开始***");

    try {

    result = x / y;

    } finally {

    System.out.println("***2、除法计算结束***");

    }

    return result;

    }

    }

    public class TestDemo {

    public static void main(String args[]) {

    try {

    System.out.println(MyMath.div(10, 0));

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    如果现在你直接使用了try...finally,那么表示你连处理一下的机会都没有,就直接抛出了。

    RuntimeException类

    先观察一个程序代码

    public class TestDemo {

    public static void main(String args[]) {

    int temp = Integer.parseInt("100"); // 将字符串变为整型数据

    }

    }

    现在来观察一下parseInt()方法的定义

    public static int parseInt(String s) throws NumberFormatException {

    return parseInt(s,10);

    }

    此时parseInt()方法抛出了NumberFormatException,按照道理来讲,应该进行强制性的异常捕获,可是现在并没有这种强制性的要求。

    来观察一下NumberFormatException的继承结构

    java.lang.Object

    --java.lang.Throwable

    ----java.lang.Exception

    ------java.lang.RuntimeException // 运行时异常

    --------java.lang.IllegalArgumentException

    ----------java.lang.NumberFormatException

    在Java里面为了方便用户代码的编写,专门提供了一种RuntimeException类,这种异常类的最大特征在于:程序在编译的时候不会强制性的要求用户处理异常,用户可以根据自己的需要选择性进行处理,但是如果没有处理又发生异常了,将交给JVM默认处理。也就是说RuntimeException的子异常类,可以由用户根据需要选择进行处理。

    解释Exception与RuntimeException的区别:

    Exception是RuntimeException的父类。

    使用Exception定义的异常必须要被处理,而RuntimeException的异常可以选择性处理。

    常见的RuntimeException:

    ArithmeticException

    NullPointerException

    ClassCastException

    assert关键字(了解)

    assert关键字是在JDK1.4的时候引入的,其主要功能是进行断言。

    在Java中的断言指的是程序执行到某行代码处于一定是预期的结果。

    范例:观察断言

    public class TestDemo {

    public static void main(String args[]) {

    int num = 10;

    // 中间可能经过了20行代码来操作num的内容

    期望中的内容应该是20

    assert num == 20 : "num的内容不是20";

    System.out.println("num = " + num);

    }

    }

    输出结果:

    num = 10

    默认情况下断言是不应该影响程序的运行的,也就是说在java解释程序的时候,断言是默认不起作用的。

    启用断言

    java -ea TestDemo

    输出结果:

    Exception in thread "main" java.lang.AssertionError: num的内容不是20...

    在Java里面断言的设计要比C++强的很多,它不会影响到程序的执行,但是使用的意义不大。

    自定义异常

    Java本身已经提供了大量的异常,但是这些异常在实际的工作之中往往并不够去使用,例如:当你要执行数据增加操作的时候,有可能会出现一些错误的数据,而这些错误的数据一旦出现就应该抛出异常,例如:AddException,这样的异常Java并没有,所以就需要由用户自己去开发一个自己的异常类。

    如果想要开发自定义的异常类可以选择继承Exception或者是RuntimeException。

    范例:定义AddException

    class AddException extends Exception {

    public Addexception(String msg) {

    super(msg);

    }

    }

    public class TestDemo {

    public static void main(String args[]) {

    int num = 20;

    try {

    if(num > 10) { // 出现了错误,应该产生异常

    throw new AddException("数值传递的过大!");

    }

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    输出结果:

    AddException:数值传递的过大!...

    这种代码只能介绍自定义异常的形式,但是并不能说明自定义异常的实际使用。

    总结

    Exception的父类是Throwable,但是在编写代码的时候尽量不要使用Throwable,因为Throwable下面还包含了一个Error子类,我们能够处理的只有Exception子类。

    异常处理的标准格式:try、catch、finally、throw、throws。

    RuntimeException与Exception的区别。

    展开全文
  • java捕获异常和抛出异常In Java 7, catch block has been improved to handle multiple exceptions in a single catch block. If you are catching multiple exceptions and they have similar code, then using ...

    java捕获异常和抛出异常

    In Java 7, catch block has been improved to handle multiple exceptions in a single catch block. If you are catching multiple exceptions and they have similar code, then using this feature will reduce code duplication. Let’s understand java catch multiple exceptions feature with an example.

    在Java 7中,对catch块进行了改进,可以在单个catch块中处理多个异常。 如果捕获多个异常并且它们具有相似的代码,则使用此功能将减少代码重复。 让我们通过一个示例来了解Java捕获多个异常功能。

    Java捕获多个异常 (Java catch multiple exceptions)

    Before Java 7, we used to catch multiple exceptions one by one as shown below.

    在Java 7之前,我们曾经一一捕获多个异常,如下所示。

    catch (IOException ex) {
         logger.error(ex);
         throw new MyException(ex.getMessage());
    catch (SQLException ex) {
         logger.error(ex);
         throw new MyException(ex.getMessage());
    }

    In Java 7, we can catch both these exceptions in a single catch block as:

    在Java 7中,我们可以在单个catch块中捕获这两个异常,如下所示:

    catch(IOException | SQLException ex){
         logger.error(ex);
         throw new MyException(ex.getMessage());
    }

    If a catch block handles multiple exceptions, you can separate them using a pipe (|) and in this case, exception parameter (ex) is final, so you can’t change it. The byte code generated by this feature is smaller and reduce code redundancy.

    如果catch块处理多个异常,则可以使用管道(|)分隔它们,在这种情况下,异常参数(ex)是最终的,因此您无法更改它。 此功能生成的字节代码较小,并减少了代码冗余。

    Java重新抛出异常 (Java rethrow exception)

    Another improvement is done in Compiler analysis of rethrown exceptions. Java rethrow exception allows you to specify more specific exception types in the throws clause of a method declaration.

    编译器对重新抛出的异常进行分析的另一项改进。 Java rethrow异常允许您在方法声明的throws子句中指定更特定的异常类型。

    Let’s see this with a small example:

    让我们来看一个小例子:

    package com.journaldev.util;
    
    public class Java7MultipleExceptions {
    
    	public static void main(String[] args) {
    		try{
    			rethrow("abc");
    		}catch(FirstException | SecondException | ThirdException e){
    			//below assignment will throw compile time exception since e is final
    			//e = new Exception();
    			System.out.println(e.getMessage());
    		}
    	}
    
    	static void rethrow(String s) throws FirstException, SecondException,
    			ThirdException {
    		try {
    			if (s.equals("First"))
    				throw new FirstException("First");
    			else if (s.equals("Second"))
    				throw new SecondException("Second");
    			else
    				throw new ThirdException("Third");
    		} catch (Exception e) {
    			//below assignment disables the improved rethrow exception type checking feature of Java 7
    			// e=new ThirdException();
    			throw e;
    		}
    	}
    
    	static class FirstException extends Exception {
    
    		public FirstException(String msg) {
    			super(msg);
    		}
    	}
    
    	static class SecondException extends Exception {
    
    		public SecondException(String msg) {
    			super(msg);
    		}
    	}
    
    	static class ThirdException extends Exception {
    
    		public ThirdException(String msg) {
    			super(msg);
    		}
    	}
    
    }

    As you can see that in rethrow method, catch block is catching Exception but it’s not part of throws clause. Java 7 compiler analyze the complete try block to check what types of exceptions are thrown and then rethrown from the catch block.

    如您所见,在rethrow方法中,catch块正在捕获Exception,但它不是throws子句的一部分。 Java 7编译器分析完整的try块,以检查引发了哪些类型的异常,然后将其从catch块中抛出。

    Note that this analysis is disabled if you change the catch block argument.

    请注意,如果更改catch块参数,则将禁用此分析。

    Further Reading: Exception Handling in Java.

    进一步阅读: Java中的异常处理

    翻译自: https://www.journaldev.com/629/java-catch-multiple-exceptions-rethrow-exception

    java捕获异常和抛出异常

    展开全文
  • Java异常捕获及处理

    千次阅读 多人点赞 2021-04-26 11:14:43
    Java异常的捕获及处理一、Java异常简介二、处理异常捕获异常异常处理流程抛出异常三种类型的异常三、Java异常的分类四、自定义异常 一、Java异常简介 什么是异常? 程序运行时,发生的不被期望的事件,它阻止了程序...
  • java线程中能不能捕获异常

    千次阅读 2018-12-28 22:01:51
    不能 ,如果要捕获异常怎么处理。我们实现UncaughtExceptionHandler这个接口来捕获抛出的异常。 由于Java线程的本质特征,当抛出异常的时候就终止了如果再进行catch,都不在一个线程里面,所以无法捕捉到异常。 ...
  • 【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——捕获异常+再次抛出异常与异常链 的相关知识;【1】捕获异常相关1.1)如果某个异常发生的时候没有再任何地方进行捕获, 那程序就...
  • JAVA异常捕获大全

    2018-07-16 20:19:02
    java所有能捕获异常大全说明,详细的说明及场景!java所有能捕获异常大全说明,详细的说明及场景!
  • Java全局异常捕获处理

    千次阅读 2021-07-21 10:49:36
    为了项目的正常运行中,异常捕获,记录也是非常重要的,方便我们排查问题,定位问题 定义异常 为了方便定位异常,自定义了几种异常类,方便我们快速定位异常。 基类 public class HttpException extends ...
  • Java异常捕获与处理

    千次阅读 2020-08-05 19:37:12
    在编程过程中,首先应当尽可能去避免错误和异常发生,对于不可避免、不可预测的情况则考虑异常发生时如何处理。 异常(Exception)也称为例外,指的是所有可能造成计算机无法正常处理的情况,如果没有实现妥善的...
  • springboot全局捕获异常

    2018-07-05 08:42:05
    springboot全局捕获异常springboot全局捕获异常springboot全局捕获异常
  • 目录标题一、捕获和处理异常二、异常抛出1. throw2. throws三、自定义异常1. 自定义异常概念2. 自定义异常类3. 示例 一、捕获和处理异常 try{} 语句块中放检查的代码,有异常就会自动抛出 catch(异常类型){} 语句...
  • java抛出异常是怎么回事?

    千次阅读 2021-02-13 00:49:01
    一、Java异常的基础知识异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误java.lang.Error;如果你用System.out....
  • 主要介绍了Java中未被捕获异常以及try语句的嵌套使用,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 今天碰到个问题,我在捕获异常时,使用了catch( Exception e),但其中的某个异常,比如NullPointException,我不想捕获,我只想捕获除了NullPointException之外的其他Exception,怎么办呢?java里面有类似cache( ...
  • Java捕获线程异常的几种方式

    万次阅读 多人点赞 2018-08-27 16:47:49
    Java捕获线程异常的几种方式,Java中在处理异常的时候,通常的做法是使用try-catch-finally来包含代码块,但是Java自身还有一种方式可以处理——使用UncaughtExceptionHandler。它能检测出某个线程由于未捕获的异常...
  • Java捕获所有异常

    千次阅读 2019-06-14 19:57:10
    即通过捕获异常类型的基类Exception就可以做到这一点: catch(Exception e){ System.out.println("Caught an exception"); } 这样我们将捕获所有异常,所以最好将它放在处理程序列表的末尾,以防止它抢在其他...
  • Spring中,使用切面全局捕获异常的同时,进行自定义异常抛出捕获,方便代码书写。
  • java异常捕获及处理

    万次阅读 多人点赞 2019-03-16 15:28:13
    什么异常? 程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常异常发生时,是任程序自生自灭,立刻退出终止。在Java中即,Java在编译或运行或者运行过程中出现的错误。 ...
  • java 捕获异常还是抛出异常

    千次阅读 2019-01-19 23:14:02
    今天在看hadoop源码时,想想自己最近在做的那个系统,发现很多异常处理的方式不对,还是按照传统的异常处理方式(即:采用返回值来标识程序出现的异常情况)。而hadoop中很多方法的声明是有异常抛出的,而我的系统中...
  • 空指针异常:NullPointException 下标越界异常:ArrayIndexOutOfBoundsException,IndexOutOfBoundsException,StringIndexOutOfBoundsException SQL参数异常:IllegalArgumentException 数学转换异常:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 191,774
精华内容 76,709
关键字:

java为什么要捕获异常

java 订阅