绕过 Java 编译器检查，在任何地方抛出受检异常

最新推荐文章于 2024-07-07 03:38:57 发布
最新推荐文章于 2024-07-07 03:38:57 发布
阅读量548 收藏
点赞数
分类专栏： Java
原文链接：https://www.liuwj.me/posts/throwing-checked-exceptions-anywhere/
版权

1 Java 异常简介

        众所周知，Java 的所有异常都派生自 Throwable 类，在继承结构上，从 Throwable 派生出了 Error 和 Exception 两大类。其中，Error 表示系统级别的严重程序错误，一般由 JVM 抛出，我们也不应该捕获这类异常，用户自定义的异常一般都派生自 Exception 类。

       从是否被编译器强制检查一点，异常又可分为受检异常(Checked Exception)和未受检异常(Unchecked Exception)。未受检异常派生自 Error 或者 RuntimeException，表示不可恢复的程序错误，典型例子有 AssertionError、NullPointerException 等，编译器不会强制我们捕获这类异常。受检异常则是除了 Error/RuntimeException 之外，派生自 Throwable 或者 Exception 的其他异常，比如 IOException、SQLException 等。

       如果一个方法声明自己可能抛出受检异常，那么编译器会强制它的调用者必须使用 try-catch 捕获此异常，或者在自己的方法中加上 throws 声明将异常继续传播给外界。 除非抛出RuntimeException或其子类，可在外部进行异常捕获。

 

 

        多年以来，Java 中受检异常的设计一直颇受争议，反对者认为，受检异常容易破坏方法声明的兼容性，会使代码的可读性降低，还增加开发的工作量等等。当然也有一些支持者，他们认为受检异常可以强迫程序员去思考，有助于他们写出更健壮的代码，可以参考王垠的文章「Kotlin 和 Checked Exception」。

2 java 中的异常处理实例

直接上代码，先贴下面测试需要调用的方法：
// catch 后续处理工作
public static boolean catchMethod() {
    System.out.print("call catchMethod and return  --->>  ");
    return false;
}
// finally后续处理工作
public static void finallyMethod() {
    System.out.println();
    System.out.print("call finallyMethod and do something  --->>  ");
}


1. 抛出 Exception，没有 finally，当 catch 遇上 return

public static boolean catchTest() {
  try {
      int i = 10 / 0;   // 抛出 Exception，后续处理被拒绝
      System.out.println("i vaule is : " + i);
      return true;    // Exception 已经抛出，没有获得被执行的机会
  } catch (Exception e) {
      System.out.println(" -- Exception --");
      return catchMethod();    // Exception 抛出，获得了调用方法并返回方法值的机会
  }
}
后台输出结果：
-- Exception --
call catchMethod and return  --->>  false


2. 抛出 Exception，当 catch 体里有 return，finally 体的代码块将在 catch 执行 return 之前被执行
public static boolean catchFinallyTest1() {
  try {
      int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
      System.out.println("i vaule is : " + i);
      return true;   // Exception 已经抛出，没有获得被执行的机会
  } catch (Exception e) {
      System.out.println(" -- Exception --");
      return catchMethod();  // Exception 抛出，获得了调用方法的机会，但方法值在 finally 执行完后才返回
  }finally{
    finallyMethod();  // Exception 抛出，finally 代码块将在 catch 执行 return 之前被执行
  }
}
后台输出结果：

 -- Exception --
call catchMethod and return  --->>  
call finallyMethod and do something  --->>  false

3. 不抛 Exception，当 finally 代码块里面遇上 return，finally 执行完后将结束整个方法

public static boolean catchFinallyTest2() {
    try {
        int i = 10 / 2;  // 不抛出 Exception
        System.out.println("i vaule is : " + i);
        return true;   // 获得被执行的机会，但执行需要在 finally 执行完成之后才能被执行
    } catch (Exception e) {
        System.out.println(" -- Exception --");
        return catchMethod();
    }finally{
        finallyMethod();
        return false; // finally 中含有 return 语句，这个 return 将结束这个方法，不会在执行完之后再跳回 try 或 catch 继续执行，方法到此结束，返回 false
    }
}


后台输出结果：
i vaule is : 5
call finallyMethod and do something  --->>  false


4. 不抛 Exception，当 finally 代码块里面遇上 System.exit() 方法 将结束和终止整个程序，而不只是方法

public static boolean finallyExitTest() {
    try {
        int i = 10 / 2;  // 不抛出 Exception
        System.out.println("i vaule is : " + i);
        return true;   // 获得被执行的机会，但由于 finally 已经终止程序，返回值没有机会被返回
    } catch (Exception e) {
        System.out.println(" -- Exception --");
        return true;
    }finally {
        finallyMethod();
        System.exit(0);// finally 中含有 System.exit() 语句，System.exit() 将退出整个程序，程序将被终止
    }
}


后台输出结果：
i vaule is : 5
call finallyMethod and do something  --->>  


5. 抛出 Exception，当 catch 和 finally 同时遇上 return，catch 的 return 返回值将不会被返回，finally 的 return 语句将结束整个方法并返回

public static boolean finallyTest1() {
    try {
        int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
        System.out.println("i vaule is : " + i);
        return true;   // Exception 已经抛出，没有获得被执行的机会
    } catch (Exception e) {
        System.out.println(" -- Exception --");
        return true;  // Exception 已经抛出，获得被执行的机会，但返回操作将被 finally 截断
    }finally {
        finallyMethod();
        return false;  // return 将结束整个方法，返回 false
    }
}


后台输出结果：
 -- Exception --
call finallyMethod and do something  --->>  false


6. 不抛出 Exception，当 finally 遇上 return，try 的 return 返回值将不会被返回，finally 的 return 语句将结束整个方法并返回

public static boolean finallyTest2() {
    try {
        int i = 10 / 2;  // 不抛出 Exception
        System.out.println("i vaule is : " + i);
        return true;   // 获得被执行的机会，但返回将被 finally 截断
    } catch (Exception e) {
        System.out.println(" -- Exception --");
        return true;
    }finally {
        finallyMethod();
        return false; // return 将结束这个方法，不会在执行完之后再跳回 try 或 catch 继续执行，返回 false
    }
}
后台输出结果：
i vaule is : 5
call finallyMethod and do something  --->>  false


结语：

java 的异常处理中（假设方法需要返回值）：

  1. 在不抛出异常的情况下，程序执行完 try 里面的代码块之后，该方法并不会立即结束，而是继续试图去寻找该方法有没有 finally 的代码块，
  2. 如果没有 finally 代码块，整个方法在执行完 try 代码块后返回相应的值来结束整个方法；
  3. 如果有 finally 代码块，此时程序执行到 try 代码块里的 return 语句之时并不会立即执行 return，而是先去执行 finally 代码块里的代码，
  4. 若 finally 代码块里没有 return 或没有能够终止程序的代码，程序将在执行完 finally 代码块代码之后再返回 try 代码块执行 return 语句来结束整个方法；
  5. 若 finally 代码块里有 return 或含有能够终止程序的代码，方法将在执行完 finally 之后被结束，不再跳回 try 代码块执行 return。

在抛出异常的情况下，原理也是和上面的一样的，你把上面说到的 try 换成 catch 去理解就 OK 了 *_*

 

###################

java异常处理-finally中使用return和throw语句

java异常语句中的finally块通常用来做资源释放操作，如关闭文件、关闭网络连接、关闭数据库连接等。正常情况下finally语句中不应该使用return语句也不应该抛出异常，以下讨论仅限于java语言设计本身，正常编码时应避免。

finally块中使用return会覆盖method的返回值

以下代码的返回值为：1

public static int div(){
        try {
            return 3;
        }catch (ArithmeticException e){
            System.out.println("catch in div");
            return 2;
        }
        finally {
            System.out.println("finally in div");
            return 1;
        }
    }

 

以下代码的返回值同样是：1

 public static int div(){
        try {
            return 3/0;
        }catch (ArithmeticException e){
            System.out.println("catch in div");
            return 2;
        }
        finally {
            System.out.println("finally in div");
            return 1;
        }
    }

 

finally块中使用return会抑制异常的冒泡传输

即：只要finally中使用了return语句，调用者便认为该方法正常返回

以下代码

/**
 * Created by Administrator on 2017/11/27.
 */

public class Test {

    public static void main(String[] args) {
        adapter();
    }

    public static void adapter() {
        try {
            div();
        } catch (ArithmeticException e) {
            System.out.println("catch in adapter");
        } finally {
            System.out.println("finally in adapter");
        }
    }

    public static int div() {
        try {
            int a = 5 / 0;
            return a;
        } catch (ArithmeticException e) {
            System.out.println("catch in div");
            throw e;  // 重新将异常抛出给调用者
        } finally {
            System.out.println("finally in div");
        }
    }
}

输出为

catch in div
finally in div
catch in adapter
finally in adapter

 

 但如果在 div 的finally块中添加了return语句

    public static int div(){
        try {
            int a =  5/0;
            return a;
        }catch (ArithmeticException e){
            System.out.println("catch in div");
            throw  e; // 重新将异常抛出给调用者，但是抛出会被忽略
        }
        finally {
            System.out.println("finally in div");
            return 1;
        }
    }

则代码的输出为

catch in div
finally in div
finally in adapter

即：finally块中的return语句会阻止异常的栈调用传输，使caller认为该方法已经正常返回

 

finally块中的throw语句会覆盖try和catch语句中的异常

以下代码

/**
 * Created by Administrator on 2017/11/27.
 */

public class Test {

    public static void main(String[] args) {
        adapter();
    }

    public static void adapter() {
        try {
            div();
        } catch (Exception e) {
            System.out.println(String.format("catch in adapter: %s",e.getMessage()));
        } finally {
            System.out.println("finally in adapter");
        }
    }

    public static int div() throws Exception{
        try {
            int a = 5 / 0;
            return a;
        } catch (ArithmeticException e) {
            System.out.println("catch in div");
            throw new Exception("Exception in div"); // 抛出新的异常
        } finally {
            System.out.println("finally in div");
            throw new Exception("Exception in Finally");  // 抛出新的异常
        }
    }
}

输出是：

catch in div
finally in div
catch in adapter: Exception in Finally
finally in adapter

即，catch块中抛出的异常北finally块抛出的异常替换了

 

修改div方法为

 public static int div() throws Exception{
        try {
            int a = 5 / 0;
            return a;
        }  finally {
            System.out.println("finally in div");
            throw new Exception("Exception in Finally");  // 抛出新的异常
        }
    }

输出为：

finally in div
catch in adapter: Exception in Finally
finally in adapter

即，try块中捕获的异常北finally块抛出的异常替换

 

finally块和普通代码块一样，无法同时使用return语句和throw语句，因为无法通过编译

zzhongcy
关注
专栏目录
简单了解Java编程中抛出异常的方法
09-03
本篇文章将详细探讨Java中如何抛出异常。 首先，我们来看如何使用`throws`关键字抛出异常。`throws`关键字用于声明一个方法可能抛出的异常。如果一个方法在执行过程中可能会遇到无法处理的异常，它可以选择不处理，...
java 清除警告的注解_忽略警告注解@SuppressWarnings详解
weixin_39764487的博客
02-26 2026
简介：java.lang.SuppressWarnings是J2SE 5.0中标准的Annotation之一。可以标注在类、字段、方法、参数、构造方法，以及局部变量上。作用：告诉编译器忽略指定的警告，不用在编译完成后出现警告信息。使用：@SuppressWarnings(“”)@SuppressWarnings({})@SuppressWarnings(value={})根据sun的官方文档描述：...
Java 绕过编译器检查抛出“受检查的”异常
不待人亲
01-23 718
个别特殊情况下，我们可能想抛出受检查的异常但却并不想在方法上加入throws XXException的signature 比如下面的代码不能成功编译： [code="java"] public static void main(String[] args){ throw new Exception(); } [/code] 需要改成这样： [code="java"] ...
JAVA编译显示存在不安全_java – 编译时出现“未经检查或不安全的操作”错误...
weixin_42371574的博客
03-02 754
参见英文答案 >What causes javac to issue the “uses unchecked or unsafe operations” warning8个我是Java编程的新手,我正在尝试向一个粗糙的小媒体播放器添加一个文件列表.看起来我已成功实现了我想要的东西：public class MusicPl...
JAVA如何直接编译代码不检测错误
最新发布
weixin_31953847的博客
07-07 53
代码示例相关视频讲解：数组-Go代码演示项目方案：JAVA如何直接编译代码不检测错误 1. 项目背景 在软件开发过程中，通常我们会通过编译器来检查代码中的错误，以确保程序运行的稳定性和可靠性。然而，在某些情况下，我们希望能够直接编译代码而不进行错误检测，这样可以节省时间并快速获得编译结果。本项目旨在提出一种方案，通过JA...
受检异常、非受检异常、异常处理、主动抛出异常
weixin_51980491的博客
01-17 1917
非受检异常（RuntimeException）：这类异常是编程人员的逻辑问题，不需要对异常进行捕获或者抛出。程序自动输入异常信息，常见的异常有：NullPointerException,ClassCastException,ArrayIndexsOutOfBoundsException、受检异常（非RuntimeException）：这类异常是由一些外部的偶然因素所引起的，必须对该类型的异常进行捕获或者抛出；受检异常可以控制义务逻辑，可在catch中处理异常带了的问题，常见的异常有：Exception, F
浅谈java中异常抛出后代码是否会继续执行
09-01
在代码3中，异常被抛出在if语句中，尽管程序可以编译，但一旦异常发生，后续的语句不会被执行，因为异常导致了当前执行路径的中断。 运行时异常（RuntimeException）是Java中的非受检异常，如NullPointerException...
Java并发编程示例(八)：处理线程的非受检异常
09-04
它们继承自RuntimeException，不需要在方法签名中声明，但默认情况下，如果非受检异常在Thread对象的`run()`方法中抛出，程序会立即终止，并在控制台打印堆栈跟踪信息。 Java为处理线程的非受检异常提供了一个机制...
2024年java面试题-java异常方面的面试题
04-21
- 当异常被捕获后，可以在`catch`块中再次抛出异常。 - 示例： ```java catch (IOException e) { throw new RuntimeException("Failed to read file", e); } ``` 10. **异常的打印**： - 使用`...
10道Java常见异常面试题含答案（很全）
01-05
Java异常处理机制是Java编程中不可或缺的一部分，它确保程序在遇到错误或异常情况时能够优雅地处理问题，而不是突然崩溃。异常（Exception）是程序运行过程中遇到问题的表示，Java提供了一系列内置异常类，例如...
java编译时出现使用了未经检查或不安全的操作解决方法
09-04
主要介绍了java编译时出现使用了未经检查或不安全的操作的解决方法,需要的朋友可以参考下
java 编译时注解处理
tinysakura的博客
07-26 4335
转载自fei20121106的博客 一、注解 Annotations是一种元数据，其作用在于提供程序本身以外的一些数据信息，也就是说Annotation他不会属于程序代码本身，不参与逻辑运算，故而不会对原程序代码的操作产生直接的影响。 一般来说Annotation有如下三种使用情形： Information for the compiler — Annotations can be used b...
使用注解取消编译器对代码的检查
努力就是魅力
03-05 1415
package annotation; /** * @SuppressWarnings("unchecked") 取消编译器对警告信息的检查 */ public class SuppressWarningDemo { public static void main(String[] args) { } } @SuppressWarnings("unchecked") c...
IDEA如何运行单个java类main方法跳过错误检查
记录日常开发过程中遇到的一些问题
09-15 2427
IDEA工具时执行java中的main方法时，如果项目中其它main方法有编译错误，会导致该main方法也无法运行，解决办法： Run -->Edit Configurations-->Application-->build no error check
Java中的包(package)和类路径的说明
zzd的博客
11-22 9104
   我看书的时候，有个疑问，写在最前面记录一下。书中是这么说的，编译器在编译源文件的时候不检查目录结构。例如，假定有一个源文件开头有下列语句：       package com.mycompany;      即使这个源文件不在子目录com/mycompany下，也可以进行编译。如果它不依赖于其他包，就不会出现编译错误。但是，最终的程序将无法运行，这是因为虚拟机找不到类文件。（对于这部分我...
第4章 对象与类
silencefly的博客
06-27 1373
第4章 对象与类 4.6 对象构造 4.6.1 重载 重载定义 如果多个方法有相同的名字、不同的参数，便产生了重载。 编译器通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。 Java 允许重载任何方法。 方法的签名 要完整地描述一个方法，需要指出方法名以及参数类型。这叫做方法的签名（signature)。 返回类型不是方法签名的一部分。 4.6.2 默认域的初始化 域的默认值 如果在构造器中没有显式地给域赋予初值，那么就会被自动地赋为默认值： 数值为 0、布尔值
java受检异常与运行时异常
zealfory
12-26 3486
正确运用异常处理机制，有助于提高程序的健壮性。 所谓程序的健壮性，就是指程序在多数情况下能够正常运行，返回预期的正确结果；如果偶尔遇到异常情况，程序也能采取周到的解决措施。 受检查异常表示程序可以处理的异常，如果抛出异常的方法本身不能处理它，那么方法调用者应该去处理它，从而使程序恢复运行，不至于终止程序。 例如，喷墨打印机在打印文件时，如果纸用完或者墨水用完，就会暂停打印，等待用户添加打印纸或更换
Java受检异常和非受检异常
拈花的专栏
11-22 3万+
Java中异常的分类 Java中所有异常，都继承自java.lang.Throwable类。 Throwable有两个直接子类，Error类和Exception类。 Exception Exception类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。 Exception可分为执行异常（RuntimeException）和检查异常（Checked E...
Controller 层返回值的公共包装类-避免每次都包装一次返回-InitializingBean增强
热门推荐
hu10131013的博客
09-07 10万+
场景：在微服务中，一般返回数据都会有个返回码、返回信息和返回消息体，但是每次返回时候调用或者是封装，太过麻烦，有没有什么办法不用每次都封装呢？ 答案是有的。 返回值对象 package com.study.auth.comm; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.annotation.JSONField; import com.alibaba.fastjson.serializer.Serialize..
Java构造函数中抛出异常的考量与分析
虽然Java允许在构造函数中抛出异常，但设计上应避免这样做。给出的 Activation code.txt 文件内容似乎与授权码或许可证相关，但与Java异常处理无关。" 在Java编程中，异常处理是程序健壮性的重要组成部分。异常处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值