精华内容
下载资源
问答
  • Java多个异常捕获顺序(多个catch)
    千次阅读
    2021-02-12 21:05:14

    Java代码

    import java.io.IOException;

    public class ExceptionTryCatchTest {

    public void doSomething() throws IOException{

    System.out.println("do somthing");

    }

    public static void main(String[] args){

    ExceptionTryCatchTest etct = new ExceptionTryCatchTest();

    try {

    etct.doSomething();

    } catch (Exception e) {

    } catch (IOException e) {

    }

    }

    }

    【问题】

    上述程序能否编译通过?为什么?

    【解答】

    不能编译通过。因为编译的时候会报错:已捕捉到异常 java.io.IOException。  catch(IOException e)这句有错误。

    分析:对于try..catch捕获异常的形式来说,对于异常的捕获,可以有多个catch。对于try里面发生的异常,他会根据发生的异常和catch里面的进行匹配(怎么匹配,按照catch块从上往下匹配),当它匹配某一个catch块的时候,他就直接进入到这个catch块里面去了,后面在再有catch块的话,它不做任何处理,直接跳过去,全部忽略掉。如果有finally的话进入到finally里面继续执行。换句话说,如果有匹配的catch,它就会忽略掉这个catch后面所有的catch。对我们这个方法来说,抛出的是IOException,当执行etct.doSomething();时,可能会抛出IOException,一但抛出IOException,它首先进入到catch (Exception e) {}里面,先和Exception匹配,由于IOException extends Exception,根据多态的原则,IOException是匹配Exception的,所以程序就会进入到catch (Exception e) {}里面,进入到第一个catch后,后面的catch都不会执行了,所以catch (IOException e) {}永远都执行不到,就给我们报出了前面的错误:已捕捉到异常 java.io.IOException。

    【总结】

    在写异常处理的时候,一定要把异常范围小的放在前面,范围大的放在后面,Exception这个异常的根类一定要放在最后一个catch里面,如果放在前面或者中间,任何异常都会和Exception匹配的,就会报已捕获到...异常的错误。

    https://blog.csdn.net/yasi_xi/article/details/23871867

    更多相关内容
  • 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-02-27 18:24:04
    Java 7中,catch块已得到改进,可以在单个catch块中处理多个异常。如果捕获多个异常并且它们...在Java 7之前,我们曾经逐一捕获多个异常,如下所示:catch (IOException ex) { logger.error(ex); throw new MyExce...

    在Java 7中,catch块已得到改进,可以在单个catch块中处理多个异常。如果捕获多个异常并且它们具有相似的代码,则使用此功能将减少代码重复。让我们通过一个例子来理解java catch多个异常特性。在Java 7之前,我们曾经逐一捕获多个异常,如下所示:

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

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

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

    如果catch块处理多个异常,可以使用竖线(|)将它们分开,在这种情况下,exception参数(ex)是final,因此无法更改它。此功能使代码更少,可减少代码冗余。

    Java重新抛出异常

    在重新抛出异常的编译器分析中完成了另一项改进。Java rethrow异常用于在方法声明的throws子句中指定更具体的异常类型。

    让我们看下面一个例子:

    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); } } }

    正如在上面所看到的,在rethrow方法中,catch块捕捉Exception,但它不是throws子句的一部分。Java 7编译器分析完整的try块以检查抛出哪些类型的异常,然后从catch块重新抛出。

    ¥ 我要打赏 纠错/补充 收藏

    哥,这回真没有了

    展开全文
  • 代码中有多个异常Java 7之前,只要我们有一个可能会生成多个异常的代码,并且如果您需要专门处理该代码,则应在一次尝试中使用多个catch块。示例以下Java程序包含一个数字数组(显示)。从用户那里,它接受此数组中...

    例外是程序执行期间发生的问题(运行时错误)。发生异常时,程序会突然终止,并且生成异常的行之后的代码将永远不会执行。

    代码中有多个异常

    在Java 7之前,只要我们有一个可能会生成多个异常的代码,并且如果您需要专门处理该代码,则应在一次尝试中使用多个catch块。

    示例

    以下Java程序包含一个数字数组(显示)。从用户那里,它接受此数组中的两个位置,然后将第一个位置的数字除以第二个位置的数字。

    输入值时-如果选择的位置不在显示的数组中,则抛出ArrayIndexOutOfBoundsException

    如果选择0作为分母,则抛出ArithmeticException。

    在此程序中,我们使用两个不同的catch块处理了所有可能的异常。import java.util.Arrays;

    import java.util.Scanner;

    public class MultipleCatchBlocks {

    public static void main(String [] args) {

    Scanner sc = new Scanner(System.in);

    int[] arr = {10, 20, 30, 2, 0, 8};

    System.out.println("Enter 3 integer values one by one: ");

    System.out.println("Array: "+Arrays.toString(arr));

    System.out.println("Choose numerator and denominator (not 0) from this array

    (enter positions 0 to 5)");

    int a = sc.nextInt();

    int b = sc.nextInt();

    try {

    int result = (arr[a])/(arr[b]);

    System.out.println("Result of "+arr[a]+"/"+arr[b]+": "+result);

    }

    catch(ArrayIndexOutOfBoundsException e) {

    System.out.println("Warning: You have chosen a position which is not in the array");

    }

    catch(ArithmeticException e) {

    System.out.println("Warning: You cannot divide a number with 0");

    }

    }

    }

    输出1Enter 3 integer values one by one:

    Array: [10, 20, 30, 2, 0, 8]

    Choose numerator and denominator(not 0) from this array (enter positions 0 to 5)

    2

    8

    Warning: You have chosen a position which is not in the array

    输出2Enter 3 integer values one by one:

    Array: [10, 20, 30, 2, 0, 8]

    Choose numerator and denominator (not 0) from this array (enter positions 0 to 5)

    1

    4

    Warning: You cannot divide a number with 0

    多捕获块

    从Java 7开始,使用此功能引入了Multicatch块,您可以在单个catch块中处理多个异常。

    在此,您需要指定所有要处理的异常类,并用“ | |”分隔。”,如下所示-catch(ArrayIndexOutOfBoundsException | ArithmeticException exp) {

    System.out.println("Warning: Enter inputs as per instructions ");

    }

    示例

    以下Java程序演示了Multicatch的用法。在这里,我们在单个catch块中处理所有异常。import java.util.Arrays;

    import java.util.Scanner;

    public class MultiCatch {

    public static void main(String [] args) {

    Scanner sc = new Scanner(System.in);

    int[] arr = {10, 20, 30, 2, 0, 8};

    System.out.println("Enter 3 integer values one by one: ");

    System.out.println("Array: "+Arrays.toString(arr));

    System.out.println("Choose numerator and denominator(not 0) from this array,

    (enter positions 0 to 5)");

    int a = sc.nextInt();

    int b = sc.nextInt();

    try {

    int result = (arr[a])/(arr[b]);

    System.out.println("Result of "+arr[a]+"/"+arr[b]+": "+result);

    }

    catch(ArrayIndexOutOfBoundsException | ArithmeticException exp) {

    System.out.println("Warning: Enter inputs as per instructions ");

    }

    }

    }

    输出1Enter 3 integer values one by one:

    Array: [10, 20, 30, 2, 0, 8]

    Choose numerator and denominator(not 0) from this array, (enter positions 0 to 5)

    0

    9

    Warning: Enter inputs as per instructions

    输出2Enter 3 integer values one by one:

    Array: [10, 20, 30, 2, 0, 8]

    Choose numerator and denominator(not 0) from this array, (enter positions 0 to 5)

    2

    4

    Warning: Enter inputs as per instructions

    展开全文
  • java多线程程序中所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉。但是无法避免的是unchecked exception,也就是RuntimeException,当抛出异常时子线程...
  • 异常的注意事项: 多个异常的捕获处理? 1.多个异常分别处理 2.多个异常一次捕获,多次处理 一个try多个catch ...catch里面定义的异常变量...注意:这里捕获可以捕获多个异常,但是在第一个arr异常之后try里面的arr...
  • java7中捕获多个异常

    千次阅读 2016-07-26 17:27:28
    java7捕获多个异常,简化语法;
  • 不完全是在Java 7之前,但我会做这样的事情:Java 6和之前的版本try{//.....}catch(Exceptionexc){if(excinstanceofIllegalArgumentException||excinstanceofSecurityException||...|exc...
  • 实际开发中,有一个场景对两种异常做同样的处理,如果分开捕获的话,他们的代码处理逻辑是一样的,显得代码有点冗余,下面方法可以同时捕获多个异常,放在一起做处理: try { //捕获内容 } catch ...
  • Java异常捕获及处理

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

    万次阅读 多人点赞 2018-08-27 16:47:49
    Java捕获线程异常的几种方式,Java中在处理异常的时候,通常的做法是使用try-catch-finally来包含代码块,但是Java自身还有一种方式可以处理——使用UncaughtExceptionHandler。它能检测出某个线程由于未捕获的异常...
  • catch(异常类型){} 语句块接收到 try{} 中锁抛出的异常对象,会寻找嫩处理这一异常catch块来进行处理(可以有多个catch块,由异常类型范围小到大排列) finally{} 不管系统有没有抛出异常语句块都会执行,一般用来...
  • 文章目录一、捕获异常1.1try...catch1.2finally代码块二、多个异常如何处理 一、捕获异常 如果异常出现的话,会立刻终止程序,所以我们要处理异常。 1、该方法不处理,而是声明抛出,由该方法的调用者来处理...
  • java 捕捉多个exception

    万次阅读 2018-04-06 16:02:47
    Java SE 7中,你可以使用单个catch语句块处理一种或多种类型的异常,并以改进的异常类型检查方式来重新抛出异常。 我们先来看一段代码: catch (IOException ex) { logger.log(ex); throw ex; catch ...
  • Java异常捕获及处理

    千次阅读 多人点赞 2021-04-26 11:14:43
    Java异常捕获及处理一、Java异常简介二、处理异常捕获异常异常处理流程抛出异常三种类型的异常三、Java异常的分类四、自定义异常 一、Java异常简介 什么是异常? 程序运行时,发生的不被期望的事件,它阻止了程序...
  • 小编典典Java 7及更高版本从Java7开始,支持多异常捕获。语法为:try {// stuff} catch (Exception1 | Exception2 ex) {// Handle both exceptions}的静态类型ex是列出的异常中最特殊的通用超类型。有一很好的功能...
  • 【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——捕获异常+再次抛出异常与异常链 的相关知识;...1.2)要想捕获个异常, 必须设置 try/catch 语句块:1.2.1...
  • 本文只是配置一简单的全局的异常捕获,如有需要可以根据实际情况开发其它异常和自定义的异常。 web页面跳转 项目结构如下: MyExceptionHandler.java import javax.servlet.http.HttpServletRequest; import ...
  • Java异常捕获与处理

    千次阅读 2020-08-05 19:37:12
    Java的程序代码在一些特定环境下,也会发生某些不测情况。在编程过程中,首先应当尽可能去避免错误和异常发生,对于不可避免、不可预测的情况则要考虑异常发生时如何处理。 异常(Exception)也称为例外,指的是所有...
  • Java 7开始,一个catch块可以捕捉多个异常。多异常捕获格式如下: catch(异常1 | 异常 2 | 异常3 ex) { } 使用一个catch块捕获多种异常时需要注意如下两点: 多个异常之间用竖线隔开。 多异常捕捉时...
  • Java异常抛出和捕获

    千次阅读 2021-02-28 15:08:42
    Java中把非正常情况分为两种,异常(Exception)和错误(Error)。异常.pngError:一般是指与虚拟机相关的问题(虚拟机错误、线程死锁等),这种错误无法回复或不可能捕获Exception:强制性要求用户必须处理...
  • Java 捕获和抛出异常

    万次阅读 2019-05-08 19:59:59
    Java中把非正常情况分为两种:异常(Exception)和错误(Error),其中Error错误一般是指与虚拟机相关的问题,这种错误无法恢复或不可能捕获,而对于Exception异常我们可以使用try…catch进行捕获。try…catch不允许...
  • 2、如果执行过程异常,可以按照自定义方式消费异常信息。 如果只是单纯的使用Callable可以实现,本文提供更加优雅的工具类。 Maven依赖 <dependency> <groupId>cn.hutool</groupId> &...
  • 捕获多个异常

    千次阅读 2017-03-10 13:59:07
    当遇到异常时,除了可以将异常抛出,还可以将其捕获。...本实例将演示如何捕获多个异常,实例运行效果如图 Java中捕获异常是通过try、catch和finally 3个块来完成的。其中try块是必需的,catch和finall
  • java AOP异常捕获导致全局异常捕获不到 https://blog.csdn.net/qq_37262094/article/details/103532560
  • java异常捕获及处理

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

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 145,381
精华内容 58,152
关键字:

java捕获多个异常

java 订阅