Java -- 异常

已于 2023-08-31 10:16:50 修改
阅读量44 收藏
点赞数
文章标签： java 开发语言
于 2023-08-30 19:28:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62093073/article/details/132589114
版权

异常

异常是指在程序执行过程中的出现的非正常现象

一个良好的程序应该具备预见并处理可能发生的各种异常情况。

因此我们利用异常处理技术，来提高程序的容错能力

异常处理体系

检查异常也称为编译时异常。

不检查异常也称运行时异常。

Error类

表示程序无法恢复的严重错误或者恢复起来比较麻烦的错误，例如内存溢出、动态链接失败等等。

应用程序不主动抛出这些错误，通常由虚拟机自动抛出。

出现这种错误，最好的处理方式是让程序安全退出。

Exception类

由Java抛出和处理的非严重错误，

Exception的不同子类对应不同类型的异常

不受检异常(运行时异常)

包括RuntinmeException及其子类

！！还有error类及子类

受检异常

除了不受检异常外，其他继承自Exception类的异常。对于这些代码要求在代码中进行处理(可以try -- catch或者继续抛出异常直到到JVM自动处理)

常见的一些异常

image-20230830162351115

3.运行时异常（不受检异常）

image-20230830162111406

4.非运行时异常（受检异常）

image-20230830162155404

两种查看异常信息的方法

public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {
            System.out.println(a/b);
        }
        catch (Exception e)
        {
​
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
​
    }

1.异常对象.getMessage()

此方法有返回值，返回报错信息

//上面的异常调用getMessage()打印下面
/ by zero

2.异常对象.printStcakTrace()

没有返回值打印堆栈信息

// 打印结果如下
java.lang.ArithmeticException: / by zero
    at code.test.Demo0830.abnormal.demo.main(demo.java:9)

捕获异常

// 基本格式
try{
    //可能出现异常的代码
}
catch(异常类名  变量名)
{
    // 异常处理
}
finally
{
    //最后执行的代码
    //不管catch是否执行，finally都会执行
}

  1. try-catch

  2. try-catch-finally

  3. try-catch-...-catch-finally

注意有return时的情况

public static void main(String[] args) {
        test();
​
    }
​
    public static void test()
    {
        try {
            System.out.println("异常前");
            System.out.println(1/0);
            System.out.println("异常后");
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
        finally {
            System.out.println("这里是finally");
        }
    }
​
//结果为
//异常前
//  / by zero
// 这里是finally
​
  public static void main(String[] args) {
        test();
​
    }
​
    public static void test()
    {
        try {
            System.out.println("异常前");
            System.out.println(1/0);
            System.out.println("异常后");
            return;
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
        finally {
            System.out.println("这里是finally");
        }
    }
​
​
// 执行结果和上面的一样

总结一下

  • try的代码先执行，遇见异常进入catch，后进入finally(即使没有异常，finally也会执行)

抛出异常

1.throws声明抛出异常

public class ejection {
    public static void main(String[] args) {
        try {
            test();
        }
        catch (Exception e)
        {
            System.out.println("你的异常信息是"+ e.getMessage());
            System.out.println("我稳稳接住你的异常");
        }
    }
    public static void test() throws Exception
    {
        System.out.println("我就想抛出异常");
        System.out.println(1/0);
​
    }
}

2.使用throw抛出异常

public class ejection1 {
​
    public static void main(String[] args) {
        try {
            test();
        }
        catch (Exception e)
        {
            System.out.println("我稳稳接住你的异常");
            System.out.println("你的异常是"+e.getMessage());
        }
​
    }
    public static void test() throws Exception {
        throw new Exception("我就想抛出一个异常");
    }
​
}
​

自定义异常

自定义异常类

public class MyNoneExpection extends Exception{
    MyNoneExpection(String message)
    {
        super(message);
    }
}
public class demo {
​
    public static void main(String[] args) {
        try {
            throw new MyNoneExpection("我就主动抛出异常");
        }
        catch (Exception e)
        {
​
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
}
​

异常链

public static void main(String[] args) {
​
        try {
            Test3();
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
​
    public static void Test1() throws MyNoneExpection
    {
            throw new MyNoneExpection("我是Test1的异常");
    }
    public static void Test2() throws Exception
    {
        try {
            Test1();
        }
        catch (Exception e)
        {
            throw new Exception("我是Test2的异常");
        }
    }
    public static void Test3() throws Exception
    {
        try {
            Test2();
        }
        catch (Exception e)
        {
            throw new Exception("我是Test3的异常");
        }
    }
//此程序 只能看到  我是Test3的异常
// 我们想要看到全部信息
解决方法一

抛出异常时Exception的重载方法

    public static void main(String[] args) {
​
        try {
            Test3();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
​
    public static void Test1() throws MyNoneExpection
    {
            throw new MyNoneExpection("我是Test1的异常");
    }
    public static void Test2() throws Exception
    {
        try {
            Test1();
        }
        catch (Exception e)
        {
            throw new Exception("我是Test2的异常",e);
        }
    }
    public static void Test3() throws Exception
    {
        try {
            Test2();
        }
        catch (Exception e)
        {
            throw new Exception("我是Test3的异常",e);
        }
    }
​
​
/*java.lang.Exception: 我是Test3的异常
    at code.test.Demo0830.abnormal.chain.Test3(chain.java:50)
    at code.test.Demo0830.abnormal.chain.main(chain.java:21)
Caused by: java.lang.Exception: 我是Test2的异常
    at code.test.Demo0830.abnormal.chain.Test2(chain.java:40)
    at code.test.Demo0830.abnormal.chain.Test3(chain.java:46)
    ... 1 more
Caused by: code.test.Demo0830.abnormal.MyNoneExpection: 我是Test1的异常
    at code.test.Demo0830.abnormal.chain.Test1(chain.java:31)
    at code.test.Demo0830.abnormal.chain.Test2(chain.java:36)
    ... 2 more*/
​
方法二 先接受上次的异常信息，然后通过异常类变量.initCause(异常对象) 将异常对象添加到一个异常对象中

 public static void main(String[] args) {
​
        try {
            Test3();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
​
    public static void Test1() throws MyNoneExpection
    {
        throw new MyNoneExpection("我是Test1的异常");
    }
    public static void Test2() throws Exception
    {
        try {
            Test1();
        }
        catch (Exception e)
        {
            Exception e1 = e;
            e1.initCause(e);
            throw new Exception("我是Test2的异常",e1);
        }
    }
    public static void Test3() throws Exception
    {
        try {
            Test2();
        }
        catch (Exception e)
        {
            Exception e1 = e;
            e1.initCause(e);
            throw new Exception("我是Test3的异常",e1);
        }
    }
​
​
/*java.lang.Exception: 我是Test3的异常
    at code.test.Demo0830.abnormal.chain.Test3(chain.java:50)
    at code.test.Demo0830.abnormal.chain.main(chain.java:21)
Caused by: java.lang.Exception: 我是Test2的异常
    at code.test.Demo0830.abnormal.chain.Test2(chain.java:40)
    at code.test.Demo0830.abnormal.chain.Test3(chain.java:46)
    ... 1 more
Caused by: code.test.Demo0830.abnormal.MyNoneExpection: 我是Test1的异常
    at code.test.Demo0830.abnormal.chain.Test1(chain.java:31)
    at code.test.Demo0830.abnormal.chain.Test2(chain.java:36)
    ... 2 more*/
​

getCause()方法

此方法返回上次异常的信息

public static void main(String[] args) {
​
        try {
            Test3();
        }
        catch (Exception e)
        {
            e.getCause().printStackTrace();
        }
    }
​
    public static void Test1() throws MyNoneExpection
    {
        throw new MyNoneExpection("我是Test1的异常");
    }
    public static void Test2() throws Exception
    {
        try {
            Test1();
        }
        catch (Exception e)
        {
            Exception e1 = e;
            e1.initCause(e);
            throw new Exception("我是Test2的异常",e1);
        }
    }
    public static void Test3() throws Exception
    {
        try {
            Test2();
        }
        catch (Exception e)
        {
            Exception e1 = e;
            e1.initCause(e);
            throw new Exception("我是Test3的异常",e1);
        }
    }
​
/*java.lang.IllegalArgumentException: Self-causation not permitted
    at java.base/java.lang.Throwable.initCause(Throwable.java:465)
    at code.test.Demo0830.abnormal.chain1.Test2(chain1.java:28)
    at code.test.Demo0830.abnormal.chain1.Test3(chain1.java:35)
    at code.test.Demo0830.abnormal.chain1.main(chain1.java:8)
Caused by: code.test.Demo0830.abnormal.MyNoneExpection: 我是Test1的异常
    at code.test.Demo0830.abnormal.chain1.Test1(chain1.java:18)
    at code.test.Demo0830.abnormal.chain1.Test2(chain1.java:23)
    ... 2 more
​
。…。…。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单点登录(十一)-----遇到问题-----cas启用mongodb验证方式报错--Unable to locate Spring NamespaceHandler for XML schema na
直到世界的尽头
02-08 3477
cas启用mongodb验证方式报错--Unable to locate Spring NamespaceHandler for XML schema namespace [http://www.springframework.org/schema/data/mongo]完整报错信息如下:二月 08, 2017 3:49:47 下午 org.apache.catalina.core.Applica
Java--异常
简之恨寒的博客
08-13 207
在程序开发中，可能会遇到程序特有的问题，那么程序员在处理这些特有的问题时，一般会自定义一些异常来使用，这样既能保证程序的安全性和稳定性，又能给出较为友好的提示，以便于使用。继承Throwable类继承Exception类继承RunTimeException类一般会选择继承Exception和RuntimeException，如果不要求调用者一定要处理抛出的异常，就继承RuntimeException。}}try {}}......
Java中关于initcause的用法说明
Rashaun`s blog
03-27 8231
initCause()这个方法就是对异常来进行包装的，目的就是为了出了问题的时候能够追根究底。因为一个项目，越往底层，可能抛出的异常类型会用很多，如果你在上层想要处理这些异常，你就需要挨个的写很多catch语句块来捕捉异常，这样是很麻烦的。如果我们对底层抛出的异常捕获后，抛出一个新的统一的异常，会避免这个问题。但是直接抛出一个新的异常，会让最原始的异常信息丢失，这样不利于排查问题。举个例子，在底层会
Java 异常处理
笔记
03-09 2465
由于我们在程序中处理了该异常，因此程序可以继续执行。除了基本的异常处理语句，Java还提供了一些高级的异常处理机制，如异常链、自定义异常类、异常处理程序等，这些机制可以帮助开发人员更好地管理和处理异常。因此，在实际工作中，我们需要根据具体的业务场景和需求，综合考虑各种因素，灵活使用异常处理等技术手段，提高程序的可靠性和稳定性。在上面的代码中，如果try块中的代码引发了IOException异常，则会将该异常包装在RuntimeException异常中，并使用initCause()方法将其与新异常相关联。
Self-causation not permitted 错误
Genmer的博客
07-15 1174
文件通过流相应到前端，代码如下 报的这个错误也不懂什么意思,有没有大佬懂的指教下 Self-causation not permitted [geocloud44,resource,admin,10.1.88.89] : 数据准备完成，即将响应到前端！ ing .... 2021-07-15 16:33:04.039 ERROR 8270 --- [XNIO-1 task-32] com.teleware.geocloud.resource.exceptionhandler.RestServiceEx
解决Android studio 导入别人项目创建本地出错问题
qq_52039993的博客
04-20 684
1.关闭Android studio和E: \ 项目名 \目录在Windows资源管理器。4.点击“添加”,输入您的Windows用户帐户名称在“输入对象名称来选择”字段。6.选择您的用户帐号在“组或用户名”部分,检查“完全控制”框中的“用户权限”部分。5.点击“检查名称”来验证这个名字是正确的,然后点击“OK”。7.单击“OK”保存更改并关闭属性窗口。3.点开“安全”选项卡,单击“编辑”。2.右键单击文件夹,选择“属性”。8.再次尝试导入项目就能解决。
Java —— 异常
m0_54344602的博客
07-31 2004
什么是异常，异常的类型，try...catch ，finally，多重catch，throws 关键字 ，throw 关键字
mchange-commons-java-0.2.11.jar
12-31
3. 日志和异常处理：库可能提供了统一的日志接口和异常处理机制，使得代码更加整洁，错误处理更加规范。 4. 其他通用工具：如字符串处理、日期时间操作、集合操作等实用工具类，简化常见的编程任务。 在实际应用中...
Java-Java异常处理教程
11-13
Java异常处理是编程中至关重要的一个环节，它帮助开发者在程序运行时捕获并处理错误，确保程序的健壮性和稳定性。在这个Java异常处理教程中，我们将深入探讨这个主题，以便提升你的Java编程技能。 首先，Java异常是...
mysql-connector-java-8.0.26.rar
08-23
8. **异常处理**：处理数据库操作可能出现的异常，如 `SQLException` 及其子类。 9. **安全性**：设置 SSL 连接、使用连接参数限制权限等。 10. **最佳实践**：避免资源泄露，及时关闭连接和结果集，优化性能。 ...
SignalR-java-client:https
05-24
适用于Java和Android的ASP.NET SignalR ASP.NET SignalR是ASP.NET开发人员的新库，它使向应用程序中添加实时Web功能变得异常简单。 什么是“实时网络”功能？ 可以让您的服务器端代码实时将内容推送到连接的客户端。...
mysql连接包mysql-connector-java-5.1.27.jar
05-31
10. **异常处理**：在处理数据库操作时，必须捕获并适当地处理可能出现的`SQLException`和其他相关异常。 总的来说，`mysql-connector-java-5.1.27.jar`是Java开发者连接到MySQL数据库的关键组件，它提供了与MySQL...
Java异常的initCause方法分析
wang0907的博客
02-26 831
1：作用说明 当我们try主某块代码发生了异常后，希望再catch中throw一个新的异常，但是又不希望丢失引起异常的原始异常则可以使用该方法设置原始异常到我们的新异常中。 2：例子 2.1：定义原始异常 public class OriginException extends Exception { public OriginException() {} public OriginException(String message) { super(message);
Java Exception
我的博客
12-11 348
Java Exception
java initcause_initcause()方法
weixin_39948824的博客
02-13 127
public Throwable initCause(Throwablecause)将此 throwable 的 cause 初始化为指定值。(该 Cause 是导致抛出此 throwable 的throwable。)此方法至多可以调用一次。此方法通常从构造方法中调用，或者在创建 throwable 后立即调用。如果此 throwable 通过 Throwable(Throwable) 或 Th...
Java Throwable initCause（）方法与示例
cumt951045的博客
07-14 593
Throwable类initCause()方法 (Throwable Class initCause() method) initCause() Method is available in java.lang package.initCause()方法在java.lang包中可用。 initCause() Method is used to instantiate the cause of t...
Throwable#initCause(Throwable) 方法
qq_37150783的博客
11-12 726
代码: //首先有个变量case private Throwable cause = this; public synchronized Throwable initCause(Throwable cause) { // 保证只能调用一次 if (this.cause != this) throw new IllegalStateExc
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1248
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
jmu-java-06异常-finally
03-16
jmu-java-06异常是Java中的一种特殊异常，通常表示发生了内存溢出。在Java中，finally块是一种特殊的代码块，它总是在try块之后执行，无论try块是否抛出异常。因此，在处理jmu-java-06异常时，可以在finally块中执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值