精华内容
下载资源
问答
  • 通常来说,大家都是对Java中的Exception进行捕获和进行相应的处理,有些人说,error就无法捕获了。其实,error也是可以捕获的。Error和Exception都是Throwable的子类。既然可以catch Throwable,那么error也是可以...
  • 自己编写异常类型 ,自定义错误异常进行全局捕捉。实现项目全局的拦截定义输出。。。
  • 主要介绍了详解Java中多线程异常捕获Runnable的实现的相关资料,希望通过本文能帮助到大家,让大家理解掌握这样的知识,需要的朋友可以参考下
  • 当APP出现Java异常、native异常和ANR时需要重启当前APP。 解决方案: 使用爱奇艺的xCrash框架进行捕获并重启。 xCrash GitHub地址: https://github.com/iqiyi/xCrash/blob/master/README.zh-CN.md 步骤一: 在...
  • JAVA异常捕获大全

    2018-07-16 20:19:02
    java所有能捕获异常大全说明,详细的说明及场景!java所有能捕获异常大全说明,详细的说明及场景!
  • 主要介绍了java异常处理机制示例(java抛出异常、捕获、断言),需要的朋友可以参考下
  • 主要介绍了java捕获异常信息存入txt文件示例,需要的朋友可以参考下
  • Java全局异常捕获处理

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

    为了项目的正常运行中,异常捕获,记录也是非常重要的,方便我们排查问题,定位问题

    定义异常

    为了方便定位异常,自定义了几种异常类,方便我们快速定位异常。

    基类

    public class HttpException extends RuntimeException {
        protected String code;
        protected Integer httpStatusCode = 500;
    }
    
    

    ParameterException

    public class ParameterException extends HttpException {
        public ParameterException(String code){
            this.code = code;
            this.httpStatusCode = 400;
        }
    }
    

    ServerErrorException

    public class ServerErrorException extends HttpException {
        public ServerErrorException(String code) {
            this.code = code;
            this.httpStatusCode = 500;
        }
    }
    
    

    UnAuthenticatedException

    public class UnAuthenticatedException extends HttpException{
        public UnAuthenticatedException(String code){
            this.code = code;
            this.httpStatusCode = 401;
        }
    }
    
    

    ForbiddenException

    public class ForbiddenException extends HttpException {
        public ForbiddenException(String code) {
            this.code = code;
            this.httpStatusCode = 403;
        }
    }
    

    NotFoundException

    public class NotFoundException extends HttpException {
        public NotFoundException(String code){
            this.httpStatusCode = 404;
            this.code = code;
        }
    }
    
    

    这里定义了我在项目中常用的几种异常,也可根据实际情况定义自己所需的异常。

    捕获异常

    捕获异常需要用到一个注解@ControllerAdvice,关于它的详细解释可查看文档

    使用方法如下,定义一个异常捕获类

    @ControllerAdvice
    public class GlobalExceptionAdvice {
    
    }
    

    这个类就已经实现了捕获全局异常的功能,下面在加上上面定义的几种异常

    @ControllerAdvice
    public class GlobalExceptionAdvice {
      @ExceptionHandler(UnAuthenticatedException.class)
      public ResponseEntity unAuthenticatedException(UnAuthenticatedException e) {
          return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(e.getCode());
      }
    
    
      @ExceptionHandler(ParameterException.class)
      public ResponseEntity handleParameterException(ParameterException e) {
          return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getCode());
      }
    
      @ExceptionHandler(ForbiddenException.class)
      public ResponseEntity handleForbiddenException(ForbiddenException e) {
          return ResponseEntity.status(HttpStatus.FORBIDDEN).body(e.getCode());
      }
    
      @ExceptionHandler(NotFoundException.class)
      public ResponseEntity handleNotFoundException(NotFoundException e) {
          return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getCode());
      }
    
      @ExceptionHandler(RuntimeException.class)
      public ResponseEntity handleRunTimeException(RuntimeException e) {
    
          return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(500);
      }
    
    
    }
    

    @ExceptionHandler注解表示该方法捕获的异常类型,就可以在不同的异常中进行不同的处理方式。

    记录异常

    捕获到异常之后我们要记录下来,方便我们对bug的追踪解决。

    记录方法有多种多样的,比如记录到数据库或者log文件中。我使用了第二种方式。

    加入依赖

       <dependency>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <optional>true</optional>
          </dependency>
         <dependency>
              <groupId>commons-logging</groupId>
              <artifactId>commons-logging</artifactId>
              <version>1.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-api</artifactId>
              <version>2.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-core</artifactId>
              <version>2.2</version>
          </dependency>
          <dependency>
              <groupId>org.apache.logging.log4j</groupId>
              <artifactId>log4j-jcl</artifactId>
              <version>2.2</version>
          </dependency>
    

    增加日志配置文件

    logback.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    
      <!-- 控制台 appender, 几乎是默认的配置 -->
      <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
          <encoder charset="UTF-8">
              <!-- 输出的日志文本格式, 其他的 appender 与之相同 -->
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
    
      <!-- info 级别的 appender -->
      <appender name="info" class="ch.qos.logback.core.rolling.RollingFileAppender">
          <!-- 日志写入的文件名, 可以是相对目录, 也可以是绝对目录, 如果上级目录不存在会自动创建 -->
          <file>./logs/info/log-stack.log</file>
          <!-- 如果是 true, 日志被追加到文件结尾; 如果是 false, 清空现存文件. 默认是true -->
          <append>true</append>
          <!-- 日志级别过滤器, 只打 INFO 级别的日志-->
          <filter class="ch.qos.logback.classic.filter.LevelFilter">
              <level>INFO</level>
              <!-- 下面2个属性表示: 匹配 level 的接受打印, 不匹配的拒绝打印 -->
              <onMatch>ACCEPT</onMatch>
              <onMismatch>DENY</onMismatch>
          </filter>
          <!-- 最常用的滚动策略, 它根据时间来制定滚动策略, 既负责滚动也负责触发滚动 -->
          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
              <!-- 设置滚动文件规则, 如果直接使用 %d, 默认格式是 yyyy-MM-dd -->
              <fileNamePattern>./logs/info/log-stack.%d{yyyy-MM-dd}.log</fileNamePattern>
              <!-- 保留14天的日志 -->
              <maxHistory>30</maxHistory>
          </rollingPolicy>
          <!-- 定义日志输出格式 -->
          <encoder charset="UTF-8">
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
    
      <!-- error 级别的 appender -->
      <appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
          <file>./logs/error/log-stack.log</file>
          <append>true</append>
          <filter class="ch.qos.logback.classic.filter.LevelFilter">
              <level>ERROR</level>
              <onMatch>ACCEPT</onMatch>
              <onMismatch>DENY</onMismatch>
          </filter>
          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
              <fileNamePattern>./logs/error/log-stack.%d{yyyy-MM-dd}.log</fileNamePattern>
              <!-- 保留7天的日志 -->
              <maxHistory>30</maxHistory>
          </rollingPolicy>
          <!-- 定义日志输出格式 -->
          <encoder charset="UTF-8">
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
      <!-- error 级别的 appender -->
      <appender name="debug" class="ch.qos.logback.core.rolling.RollingFileAppender">
          <file>./logs/debug/log-stack.log</file>
          <append>true</append>
          <filter class="ch.qos.logback.classic.filter.LevelFilter">
              <level>DEBUG</level>
              <onMatch>ACCEPT</onMatch>
              <onMismatch>DENY</onMismatch>
          </filter>
          <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
              <fileNamePattern>./logs/debug/log-stack.%d{yyyy-MM-dd}.log</fileNamePattern>
              <!-- 保留7天的日志 -->
              <maxHistory>30</maxHistory>
          </rollingPolicy>
          <!-- 定义日志输出格式 -->
          <encoder charset="UTF-8">
              <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %L - %msg%n</pattern>
              <charset>UTF-8</charset>
          </encoder>
      </appender>
      <!-- 指定 com.github 下的日志打印级别, appender -->
      <logger name="com.github" level="debug" additivity="false">
          <appender-ref ref="stdout"/>
          <appender-ref ref="info"/>
          <appender-ref ref="error"/>
          <appender-ref ref="debug"/>
    
      </logger>
    
    
      <root level="info">
          <appender-ref ref="stdout"/>
          <appender-ref ref="info"/>
          <appender-ref ref="error"/>
      </root>
    
    </configuration>
    

    写入日志

    @ControllerAdvice
    @Slf4j
    public class GlobalExceptionAdvice {
        @ExceptionHandler(ParameterException.class)
        public ResponseEntity handleParameterException(ParameterException e) {
            log.error(e.getLocalizedMessage()); 
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getCode());
        }
    }
    

    完善异常信息

    文章中的异常只定义了code,具体的异常信息可以写在配置文件中或者保存在数据库中,在捕获到异常之后,找到对应的描述信息返回调用者,增加友好度。

    完善记录日志

    以上如果发生了异常,在日志文件中是这样记录的

    10:19:32.024 [http-nio-8080-exec-2] ERROR c.g.e.d.advice.GlobalExceptionAdvice 41 - / by zero
    

    发现记录的行号是在GlobalExceptionAdvice类中,并非是代码真实的位置。

    如果要记录到代码的真实位置可以这样实现

     public  String getExceptionDetail(Exception e) {
    
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(e.getClass() + System.getProperty("line.separator"));
            stringBuilder.append(e.getLocalizedMessage() + System.getProperty("line.separator"));
            StackTraceElement[] arr = e.getStackTrace();
            for (int i = 0; i < arr.length; i++) {
                stringBuilder.append(arr[i].toString() + System.getProperty("line.separator"));
    
            }
            return stringBuilder.toString();
        }
    
     log.error(getExceptionDetail(e));
    

    根据实际情况选择适合自己的方式

    完整代码

    Github

    Gitee

    展开全文
  • 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中异常捕获及处理

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

    一、Java异常简介

    什么是异常?
    程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常。异常发生时,是任程序自生自灭,立刻退出终止。在Java中即,Java在编译或运行或者运行过程中出现的错误

    Java提供了更加优秀的解决办法:异常处理机制。

    异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续执行,且保持代码的清晰。
    Java中的异常可以是函数中的语句执行时引发的,也可以是程序员通过throw 语句手动抛出的,只要在Java程序中产生了异常,就会用一个对应类型的异常对象来封装异常,JRE就会试图寻找异常处理程序来处理异常。

    Java异常机制用到的几个关键字:try、catch、finally、throw、throws。

    •  try        -- 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。
    • catch   -- 用于捕获异常。catch用来捕获try语句块中发生的异常。
    • finally  -- finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。
    • throw   -- 用于抛出异常。
    • throws -- 用在方法签名中,用于声明该方法可能抛出的异常。主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出,就表示在主方法里面可以不用强制性进行异常处理,如果出现了异常,就交给JVM进行默认处理,则此时会导致程序中断执行。

    产生异常的原因:

    • 用户输入了非法数据。
    • 要打开的文件不存在。
    • 网络通信时连接中断,或者JVM内存溢出。

    这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。

    三种类型的异常:

    • 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
    • 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
    • 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。

    二、Java异常的分类

    异常的根接口Throwable,其下有2个子接口,Error和Exception。

    •  Error:指的是JVM错误,这时的程序并没有执行,无法处理;
    • Exception:指的是程序运行中产生的异常,用户可以使用处理格式处理。

    Java 内置异常类

    Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常

    异常描述
    ArithmeticException当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。
    ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。
    ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。
    ClassCastException当试图将对象强制转换为不是实例的子类时,抛出该异常。
    IllegalArgumentException抛出的异常表明向方法传递了一个不合法或不正确的参数。
    IllegalMonitorStateException抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
    IllegalStateException在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
    IllegalThreadStateException线程没有处于请求操作所要求的适当状态时抛出的异常。
    IndexOutOfBoundsException指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。
    NegativeArraySizeException如果应用程序试图创建大小为负的数组,则抛出该异常。
    NullPointerException当应用程序试图在需要对象的地方使用 null 时,抛出该异常
    NumberFormatException当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
    SecurityException由安全管理器抛出的异常,指示存在安全侵犯。
    StringIndexOutOfBoundsException此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。
    UnsupportedOperationException当不支持请求的操作时,抛出该异常。

    下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类

    异常描述
    ClassNotFoundException应用程序试图加载类时,找不到相应的类,抛出该异常。
    CloneNotSupportedException当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。
    IllegalAccessException拒绝访问一个类的时候,抛出该异常。
    InstantiationException当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。
    InterruptedException一个线程被另一个线程中断,抛出该异常。
    NoSuchFieldException请求的变量不存在
    NoSuchMethodException请求的方法不存在

    异常方法

    下面的列表是 Throwable 类的主要方法:

    序号方法及说明
    1public String getMessage()
    返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
    2public Throwable getCause()
    返回一个Throwable 对象代表异常原因。
    3public String toString()
    使用getMessage()的结果返回类的串级名字。
    4public void printStackTrace()
    打印toString()结果和栈层次到System.err,即错误输出流。
    5public StackTraceElement [] getStackTrace()
    返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
    6public Throwable fillInStackTrace()
    用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

    三、异常的使用及执行流程

    1、异常的处理方案

    try...catch、try...catch...finally、try...finally
        try{
            可能会发生的异常
        }catch(异常类型 异常名(变量)){
            针对异常进行处理的代码
        }catch(异常类型 异常名(变量)){
            针对异常进行处理的代码
        }...
        [finally{
            释放资源代码;
        }]

    注意:

    • catch 不能独立于 try 存在。
    • catch里面不能没有内容
    • 在 try/catch 后面添加 finally 块并非强制性要求的。
    • try 代码后不能既没 catch 块也没 finally 块。
    • try里面越少越好。
    • try, catch, finally 块之间不能添加任何代码。
    • finally里面的代码最终一定会执行(除了JVM退出)
    • 如果程序可能存在多个异常,需要多个catch进行捕获。
    • 异常如果是同级关系,catch谁前谁后没有关系
      如果异常之间存在上下级关系,上级需要放在后面

    2、异常的执行流程

    Error与Exception的区别:

    Error(错误)是系统中的错误,程序员是不能改变的和处理的,是在程序编译时出现的错误,只能通过修改程序才能修正。一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢等。对于这类错误的导致的应用程序中断,仅靠程序本身无法恢复和和预防,遇到这样的错误,建议让程序终止。

    Exception(异常)表示程序可以处理的异常,可以捕获且可能恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。

    在catch捕获异常时,为什么不考虑使用Throwable类型,而只是使用Exception来进行接收?

    Throwable表示的范围要比Exception大。实际上程序使用Throwable来进行处理,没有任何语法问题,但是却会存在逻辑问题。因为此时出现的(或者说用户能够处理的)只有Exception类型,而如果使用Throwable接收,还会表示可以处理Error的错误,而用户是处理不了Error错误的,所以在开发中用户可以处理的异常都要求以Exception类为主。

    异常是一起处理好还是分开处理好?

    根据实际的开发要求是否严格来决定。在实际的项目开发项目工作中,所有的异常是统一使用Exception处理还是分开处理,完全根据开发者的项目开发标准来决定。如果项目开发环境严谨,基本上要求针对每一种异常分别进行处理,并且要详细记录下异常产生的时间以及产生的位置,这样可以方便程序维护人员进行代码的维护。再次注意:处理多个异常时,捕获范围小的异常要放在捕获范围大的异常之前处理。

    throw和throws的区别?

    throw和throws都是在异常处理中使用的关键字,区别如下:

    • throw:指的是在方法中人为抛出一个异常对象(这个异常对象可能是自己实例化或者抛出已存在的);
    • throws:在方法的声明上使用,表示此方法在调用时必须处理异常。

    检查型异常(Checked Exception)与非检查型异常(Unchecked Exception)区别?

    • 所有的检查性异常都继承自java.lang.Exception;所有的非检查性异常都继承自java.lang.RuntimeEx ception。
    • 检查性异常和非检查性异常最主要的区别在于其处理异常的方式:检查性异常必须使用try catch或者throws等关键字进行处理,否则编译器会报错;非检查性异常一般是程序代码写的不够严谨而导致的问题,可以通过修改代码来规避。
    • 常见的运行时异常:空指针异常(NullPointerException)、除零异常(ArithmeticException)、数组越界异常(ArrayIndexOutOfBoundsException)等;
    • 常见的检查性异常:输入输出异常(IOException)、文件不存在异常(FileNotFoundException)、SQL语句异常(SQLException)等。

    assert关键字(了解)

    在Java中,assert关键字是从JAVA SE 1.4 引入的,为了避免和老版本的Java代码中使用了assert关键字导致错误,Java在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都 将忽略!),如果要开启断言检查,则需要用开关-enableassertions或-ea来开启。

    assert关键字语法很简单,有两种用法:

    1. assert <boolean表达式>
      如果<boolean表达式>为true,则程序继续执行。
      如果为false,则程序抛出AssertionError,并终止执行。
    2. assert <boolean表达式> : <错误信息表达式>
      如果<boolean表达式>为true,则程序继续执行。
      如果为false,则程序抛出java.lang.AssertionError,并输入<错误信息表达式>。

    例如:

    public class Test {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 2;
    		assert a == 10:"a不等于10";
    		System.out.println("a="+a);
    	}
    }

     执行结果为:

    public class Test {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 2;
    		assert a == 20:"a不等于20";
    		System.out.println("a="+a);
    	}
    }

    执行结果为:

    四、自定义异常

    在 Java 中你可以自定义异常。如果要自定义异常类,则扩展Exception类即可,因此这样的自定义异常都属于检查异常(checked exception)。如果要自定义非检查异常,则扩展自RuntimeException。

    按照国际惯例,自定义的异常应该总是包含如下的构造函数:

    • 一个无参构造函数
    • 一个带有String参数的构造函数,并传递给父类的构造函数。
    • 一个带有String参数和Throwable参数,并都传递给父类构造函数
    • 一个带有Throwable 参数的构造函数,并传递给父类的构造函数。

    下面是IOException类的完整源代码,可以借鉴。

    package java.io;
    
    public class IOException extends Exception {
        static final long serialVersionUID = 7818375828146090155L;
    
        public IOException() {
    	super();
        }
    
        public IOException(String message) {
    	super(message);
        }
    
        public IOException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public IOException(Throwable cause) {
            super(cause);
        }
    }
    

    finally块和return

    • 首先一个不容易理解的事实:在 try块中即便有return,break,continue等改变执行流的语句,finally也会执行。
    • finally中的return 会覆盖 try 或者catch中的返回值。
    • finally中的return或异常会抑制(消灭)前面try或者catch块中的异常。
    展开全文
  • JAVA异常捕获

    2014-09-22 13:37:42
    JAVA异常捕获,课程笔记,毕向东的课程视频。
  • 主要为大家详细介绍了java实现系统捕获异常发送邮件案例,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——捕获异常+再次抛出异常与异常链 的相关知识;【1】捕获异常相关1.1)如果某个异常发生的时候没有再任何地方进行捕获, 那程序就...

    【0】README

    0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——捕获异常+再次抛出异常与异常链 的相关知识;

    【1】捕获异常相关

    1.1)如果某个异常发生的时候没有再任何地方进行捕获, 那程序就会运行终止: 并在控制台上打印出异常信息 , 其中包括异常的类型堆栈的内容;

    1.2)要想捕获一个异常, 必须设置 try/catch 语句块:

    1.2.1)如果在try语句块中抛出了一个在 catch子句中声明的异常类, 那么case1)程序将跳过try 语句块的其余代码;

    case2)程序将执行 catch 子句中 的处理器代码;

    1.2.2)如果在try语句块中没有抛出任何异常, 那么程序将跳过 catch子句;

    1.2.3)如果方法中的任何代码抛出了一个在 catch 子句中没有声明的异常类型, 那么这个方法就会立刻退出;

    1.3)看个荔枝: (看一个读取文本的程序代码以演示捕获异常的处理过程)

    public void read(String filename)

    {

    try

    {

    InputStream in = new FileInputStream(filename); // 创建输入流

    int b;

    while((b=in.read()) != -1)

    process input

    }

    catch(IOException exception)

    {

    exception.printStackTrace(); // 打印栈轨迹;

    }

    }

    对上述代码的分析(Analysis):

    A1)需要注意的是, try 语句中的大多数代码都很容易理解, 读取并处理文本行, 直到遇到文件结束符为止;(read 方法可能抛出一个IOException异常)

    A2)在这种情况下, 将跳出整个while循环, 进入 catch子句, 并生成一个 栈轨迹;

    1.4)对于一个普通 的程序来说, 处理以上的对异常处理的方法外,还有其他方法吗?

    1.4.1)通常, 最好的选择是: 什么也不做, 而是将异常传递给调用者;如果read方法出现了错误, 那就让read方法的调用者去处理。

    1.4.2)如果采用这种方式, 就必须声明这个方法可能抛出一个 IOException(将异常传递给调用者);

    public void read(String filename) throws IOException

    {

    InputStream in = new FileInputStream(filename); // 创建输入流

    int b;

    while((b=in.read()) != -1)

    process input

    }

    Attention)编译器严格地执行 throws 说明符。 如果调用了一个抛出已检查异常的方法, 就必须对它进行处理, 或者将它继续进行传递;

    1.5)对于以上两种处理异常的方法, 哪种 方法更好呢?(method1:自己处理(在可能发生异常的函数中添加try/catch 语句块);method2:将异常传递(throw)给调用者,调用者处理)

    1.5.1)通常, 应该捕获那些知道如何处理的异常, 而将那些不知道怎么处理的异常继续进行传递;如果想传递一个异常, 就必须在方法的首部添加一个throws 说明符, 以便告知调用者这个方法可能会抛出异常;

    1.5.2)阅读API后, 以便知道这个方法可能会抛出哪种异常, 然后再决定是自己处理, 还是添加到 throws 列表中;

    Attention)以上规则有个例外: 前面提到, 如果编写一个 覆盖超类的方法, 而这个方法又没有抛出异常, 那么这个方法就必须捕获方法代码中出现的每一个已检查异常。不允许在子类的 throws 说明符中出现超过超类方法所列出的异常类范围;(也就是说父类方法没有抛出异常,你子类方法也不准抛出异常,只能自己添加 try/catch 语句块自己处理)

    【2】捕获多个异常

    2.1)在一个try 语句块中可以捕获多个异常, 并对不同类型的异常做出不同的处理。可以按照下列方式为每个异常类型使用一个单独的 catch 子句;

    try

    {}

    catch(FileNotFoundException e)

    {}

    catch(UnknownHostException e)

    {}

    catch(IOException e)

    {}

    2.2)要想获得异常对象 的更多信息: 可以试着使用 e.getMessage() 得到详细的错误信息, 或者使用 e.getClass().getName(); 得到异常对象 的实际类型;

    2.3)合并catch 子句: 在 java SE7中, 同一个 catch 子句中可以捕获多个异常类型。 例如, 假设对应缺少文件和 未知主机异常的动作是一样的, 就可以合并catch 子句:

    try

    {}

    catch(FileNotFoundException | UnknownHostException e)

    {}

    catch(IOException e)

    {}

    Attention)

    A1)只有当捕获的异常类型彼此间不存在子类关系时 才需要这个特性;

    A2)捕获多个异常时, 异常变量隐含为 final变量。例如, 不能在以下子句体中为 e 赋不同的 值;

    catch(FileNotFoundException || UnknownHostException e) {}

    A3)捕获多个异常不仅会让你的代码看起来简单, 还会更高效。生成的字节码只包含一个对应公共catch 子句的代码块;

    【3】再次抛出异常与异常链

    3.1)在catch子句中可以抛出一个异常, 这样做的目的是 改变异常类型;

    3.1.1)看个荔枝:

    try

    {}

    catch(SQLException e)

    {

    throw new ServletException("data error : " + e.getMessage());

    }

    对以上代码的分析(Analysis):

    A1)这里, ServletException 用带有异常信息文本的构造器来构造;

    A2)不过, 可以有一种更好的方法, 并且将原始异常设置为新异常的原因:

    try

    {}

    catch(SQLException e)

    {

    Throwable se = new ServletException("database error");

    se.initCause(e);

    throw se;

    }

    A3)当捕获到这个异常时, 就可以使用下面的语句重新得到 原始异常:

    Throwable e = se.getCause();

    Attention)强烈建议使用这种包装技术, 这样可以让用户抛出子系统中的高级异常, 而不会丢失原始异常的小细节; (推荐使用 strongly recommended)

    Hint)

    H1)如果在一个方法中发生了一个已检查异常,而不允许抛出它, 那么包装技术就十分有用。 我们还可以捕获这个已检查异常, 并将它包装成一个 运行时异常;

    H2)有时候, 你可能只想记录一个异常,再将它重新抛出, 而不做任何改变:

    try

    {

    access the database

    }

    catch(Exception e)

    {

    logger.log(level, message, e);

    throw e;

    }

    H3)在Java SE7 之前, 将上述代码放入下述方法中, 会出现一个问题;

    public void updateRecord() throws SQLException

    因为, java 编译器查看catch 块中的 throw 语句, 然后查看e的类型, 会指出这个方法可以抛出任何Exception而不仅仅是 SQLException;

    H4)java se 7之后(编译器检测语法合法): 编译器会跟踪到 e 来自于try块中, 假设这个 try 块中仅有 的已检查异常 是 SQLException实例, 另外,假设e在catch块中未改变, 将外围方法声明为 throws SQLException 就是合法的;

    展开全文
  • 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全局异常捕获

    千次阅读 2019-09-18 15:57:37
    import java.lang.reflect.UndeclaredThrowableException; /** * 全局异常处理配置 * @author EternalRay */ @ControllerAdvice @ResponseBody @Slf4j public class GlobalExceptionHandleConf { /** * 顶级...
  • java AOP异常捕获导致全局异常捕获不到 https://blog.csdn.net/qq_37262094/article/details/103532560
  • java 的全局异常捕获机制

    千次阅读 2018-09-05 15:03:20
    我们讲这个全局异常捕获器UncaughtExceptionHandler之前,我们先来想个问题,先看下下面这段代码和一张图片 public class SecnodActivity extends BaseActivity{ @Override protected void onCreate(@Nullable ...
  • Java捕获线程异常的几种方式

    万次阅读 多人点赞 2018-08-27 16:47:49
    Java捕获线程异常的几种方式,Java中在处理异常的时候,通常的做法是使用try-catch-finally来包含代码块...当一个线程由于未捕获异常而退出时,JVM会把这个事件报告给应用程序提供的UncaughtExceptionHandler异常处理器
  • Java 类库定义的可以通过预检查方式规避的RuntimeException异常不应该通过 catch 的方式来处理,比如:NullPointerException,IndexOutOfBoundsException 等。
  • java多线程程序,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉,通过此篇文章给大家分享Java多线程之多线程异常捕捉,需要的朋友可以参考下
  • java全局异常捕获

    千次阅读 2016-05-18 21:55:07
    Thread.setDefaultUncaughtException() 捕获所有程序为直接处理的,由虚拟机抛出的异常。Thread t = new Thread();...捕获该线程抛出的程序本身未处理的异常。在上述两种方法如果抛出了新的异常则会被JVM忽略。
  • Java注解全局异常捕获

    2020-07-26 22:21:57
    全局异常捕获 package com.example.demo.controller; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; import org.spring...
  • 1. try-catch语句在Java中异常通过try-catch语句捕获。其一般语法形式为:try {// 可能会发生异常的程序代码} catch (Type1 id1){// 捕获并处置try抛出的异常类型Type1}catch (Type2 id2){//捕获并处置try抛出的...
  • Spring,使用切面全局捕获异常的同时,进行自定义异常抛出捕获,方便代码书写。
  • Java异常捕获及处理(详细)

    千次阅读 2020-06-02 19:13:00
      我们在写程序的时候是为了描述现实生活的事物,那么现实生活的事物也会存在一些问题,问题本身也是现实生活的一个具体事物,也可以通过java类的形式封装成对象进行描述,java对此称为——异常,其实就是...
  • Java捕获所有异常

    千次阅读 2019-06-14 19:57:10
    即通过捕获异常类型的基类Exception就可以做到这一点: catch(Exception e){ System.out.println("Caught an exception"); } 这样我们将捕获所有异常,所以最好将它放在处理程序列表的末尾,以防止它抢在其他...
  • * 标题:Java中异常捕获与处理 [入门级别] * 作者Nstar * 时间:2020年3月20号 * 程序的异常分为“运行异常”和“已知异常” ,异常就像我们开车遇到了障碍物,要绕开一样 * 程序员在编写程序,需要用到异常,...
  • 主要介绍了Spring异常捕获且回滚事务解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • JAVA中的自定义异常捕获

    千次阅读 2016-05-01 23:30:21
    JAVA中提供了自定义异常类,虽说尽量使用定义好的类,但是有时候还是会使用到自定义异常类。 自定义异常类格式如下: class /*自定义异常类名*/ extends Exception { public /*自定义异常类名*/ //相当于重写其构造...
  • 主要介绍了Java中未被捕获异常以及try语句的嵌套使用,是Java入门学习的基础知识,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,350
精华内容 73,740
关键字:

java中的异常捕获异常

java 订阅