Java面向对象编程-异常篇Exception 小结

最新推荐文章于 2024-06-25 19:58:06 发布
最新推荐文章于 2024-06-25 19:58:06 发布
阅读量202 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java
原文链接：https://my.oschina.net/360yg/blog/3006245
本文深入解析Java异常机制，包括异常分类、处理流程及代码示例。探讨如何利用异常类提高程序可读性和灵活性，以及finally关键字的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

为什么80%的码农都做不了架构师？>>>   hot3.png

  • java 异常机制的特点
    1、把各种不同的类型的异常情况进行分类，用java类来表示异常情况，称为异常类
    2、异常流程的代码和正常流程的代码分离，提高程序的可读性，简化结构
    3、可以灵活的处理异常，如当前方法有能力处理异常，就捕获并且处理它 try...catch... ，
         否则只需要抛出异常 throws exception，由方法调用者来处理它。
  • java虚拟机方法调用栈
    72f3f4a22ba5ae5c22554f14f0d8d58d6c0.jpg
  • package Exception;

/**
 * Created by yg on 2019/1/26.
 */
public class ExceptionDemo {

    public void methodA(int money) throws SpecialException {
        if (money < 0) throw new SpecialException("异常啦~~~");
        System.out.println("--- methodA，这里执行不到"); // throw new 一抛出，后面剩下的代码都不会执行啦...
    }

    public void methodB1(int money) throws SpecialException {
        methodA(money);
        System.out.println("--- methodb");
    }

//    public void methodB2(int money) {
//
//        try {
//            methodA(money);
//        } catch (SpecialException e) {
//            System.out.println("--- 这个异常我可以自己处理，就不让别人擦屁股");
//            e.printStackTrace();
//        }
//    }

//    public static void main(String args[])  {
//        try {
//            new ExceptionDemo().methodB1(-1);
//        } catch (SpecialException e) {
//            e.printStackTrace(); // 异常处理了，仅仅是打印而已，总比不写任何处理好啊..
//        }
//    }

    public static void main(String args[]) throws SpecialException {
        System.out.println("---我仅仅抛出异常了，可我已经是主线程了，" +
                "系统会自动调用异常对象的 pringStackTrace（)）方法，打印来自方法调用栈的异常信息");
        new ExceptionDemo().methodB1(-1);
    }

//    public static void main(String args[])  {
//        new ExceptionDemo().methodB2(-1);
//    }
}
  • finally 关键字，顾名思义，最终一定要做点什么事情， 不管 try代码中是否出现异常，都会执行finally代码块！！！ 
    public void methodB2(int money) {
    try {
        methodA(money);
    } catch (SpecialException e) {
        System.out.println("--- 被methodB 捕获了，继续执行下面的代码");
        e.printStackTrace();
    } finally {
        System.out.println("--- 我处理完异常了！！！");
    }
}
    不建议用下面这个写法，缺点有两个：
1、程序太松散，可读性差
2、万一 catch 里面继续抛出异常，就会被跳过去，不执行 "--- 我处理完异常了！！！"。
public void methodB2(int money) {
    try {
        methodA(money);
    } catch (SpecialException e) {
        System.out.println("--- 被methodB 捕获了，继续执行下面的代码");
        e.printStackTrace();
    }
    System.out.println("--- 我处理完异常了！！！");
}

    finally 来个案例分析吧
public class ExceptionDemo {

    public void methodA(int money) throws SpecialException {
        if (money < 0) throw new SpecialException("异常啦~~~");
        System.out.println("--- methodA，这里执行不到");
    }
    public void methodB3(int money) throws SpecialException {
        try {
            methodA(money);
        } catch (SpecialException e) {
            System.out.println("--- 第1步：被methodB 捕获了，继续执行下面的代码");
            if (money < 0) {
                System.out.println("--- 第2步：我草，我又抓了一个异常，继续抛出");
                throw e;
            }
        } finally {
            System.out.println("--- 第3步：catch完调用finally"); // try catch 执行完 立马执行自己的finally代码块，不用管catch里面继续抛出的异常.
        }
        System.out.println("--- 我处理完异常了！！！"); 这句不执行，为啥？catch里面又抛出异常了啊！！！
    }

    public static void main(String args[]) {
        try {
            new ExceptionDemo().methodB3(-1);
        } catch (SpecialException e) {
            System.out.println("--- 第4步：终于来问这里了方式");
        } finally {
            System.out.println("--- 第5步：我还得屁股擦一擦");
        }
    }
}
执行结果如下：
--- 第1步：被methodB 捕获了，继续执行下面的代码
--- 第2步：我草，我又抓了一个异常，继续抛出
--- 第3步：catch完调用finally
--- 第4步：终于来问这里了方式
--- 第5步：我还得屁股擦一擦
注意：第3步在第4步之前执行
    我们把main函数改一改如下：
public static void main(String args[]) throws SpecialException {
    try {
        new ExceptionDemo().methodB3(-1);
    } finally {
        System.out.println("---- 屁股擦一擦");
    }
}
执行结果又是如何呢？？？
--- 第1步：被methodB 捕获了，继续执行下面的代码
--- 第2步：我草，我又抓了一个异常，继续抛出
--- 第3步：catch完调用finally
---- 屁股擦一擦
Exception in thread "main" Exception.SpecialException: 异常啦~~~
    at Exception.ExceptionDemo.methodA(ExceptionDemo.java:12)
    at Exception.ExceptionDemo.methodB3(ExceptionDemo.java:20)
    at Exception.ExceptionDemo.main(ExceptionDemo.java:37)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
  • throws : 用来声明可能出现的异常，可以抛出多个异常，特点：有throw的地方一定有throws 
    public void method()  throws SQLException,IOException{...}
  • 异常处理 语法规则，这个笔试的时候回碰到
    1、try 后面可以跟多个catch 
    try {
    methodA(money);
} catch (SpecialException e) {
    System.out.println("--- 被methodB 捕获了，继续执行下面的代码");
    e.printStackTrace();
} catch (SQLException e) {
    e.printStackTrace();
}
     2、try后面没有catch，但必须有finally 代码块，catch和finally至少得有一种。 
    public static void main(String args[]) throws SpecialException {
    try {
        new ExceptionDemo().methodB1(-1);
    } finally {
        System.out.println("---- 屁股擦一擦");
    }
}
  • finally 什么时候不会执行呢？这时候出现了一个学渣exit(0)，他有背景，看到我你只能立马提裤子走人。 
    public static void main(String args[]) throws SpecialException {
    try {
        System.out.println("----大便的时候学渣来捣乱...");
        System.exit(0);
        new ExceptionDemo().methodB3(-1);
    } finally {
        System.out.println("---- 屁股都还没擦....");
    }
}
结果呢！！！ 你没看错，碰到学渣连屁股都没有擦一擦就跑走了，怕被他玩死...
----大便的时候学渣来捣乱...
Process finished with exit code 0
tips：如果在执行try代码块中调用了exit(0),则finally代码块以及try...finally 语句后面的代码都不会执行。
  • return 语句，在执行try 或 catch 代码块中的return语句时，假如有finally代码块，会先执行finally代码块，然后再return出来 
    Demo1：先执行 finally代码块，再执行try的return
public class ExceptionDemo {

    public int methodA(int money) {
        System.out.println("--- methodA");
        return -100;
    }

    public int methodB5(int money) {
        try {
            System.out.println("--- begin");
            int result = methodA(money);
            System.out.println("----执行B");
            return result;    // 浅黄后执行
        } finally {
            System.out.println("--- final");  // 深黄先执行
        }
    }

    public static void main(String args[]) {
        System.out.println("--- result:" + new ExceptionDemo().methodB5(-1));
    }
}

执行结果：
--- begin
--- methodA
----执行B
--- final
--- result:-100
    Demo2：先执行finally代码块，再执行catch里面的return
public class ExceptionDemo {

    public int methodA(int money) throws SpecialException {
        if (money < 0) {
            throw new SpecialException("异常啦~~~");
//            return -200;  unreachble statement
        }
        System.out.println("--- methodA，这里执行不到");
        return -100;
    }

    public int methodB5(int money) {
        try {
            System.out.println("--- begin");
            int result = methodA(money);
            System.out.println("---- 这里不会执行，有异常，已被捕获了呢");
            return result; // 浅黄后执行
        } catch (SpecialException e) {
            System.out.println("--- message:" + e.getMessage());
            return -200;
        } finally {
            System.out.println("--- final"); // 深黄先执行
        }
    }

    public static void main(String args[]) {
        System.out.println("--- result:" + new ExceptionDemo().methodB5(-1));
    }
}

执行结果：
--- begin
--- message:异常啦~~~
--- final
--- result:-200
  • 变量：finally 代码块不能通过重新给变量赋值的方式来改变 return 语句的返回值，这个经常笔试会碰到！！！
    e073474d69702ed5631d8d642576ed3b81f.jpg
  • 如果finally里面直接return呢？？？ 
    public class ExceptionDemo {

    public int methodA(int money) throws SpecialException {
        if (money < 0) {
            throw new SpecialException("异常啦~~~");
//            return -200;  unreachble statement
        }
        System.out.println("--- methodA，这里执行不到");
        return -100;
    }

    public int methodB5(int money) {
        try {
            System.out.println("--- begin");
            int result = methodA(money);
            System.out.println("---- 这里不执行，有异常，已被捕获了");
            return result; // 不执行
        } catch (SpecialException e) {
            System.out.println("--- message:" + e.getMessage());
            return -200;   // 不执行
        } finally {
            System.out.println("--- final");
            return 300;   // 这finally里面return 会覆盖try和catch里面的return,以这里面的return为准。
        }
    }

    public static void main(String args[]) {
        System.out.println("--- result:" + new ExceptionDemo().methodB5(-1));
    }
}
结果：
--- begin
--- message:异常啦~~~
--- final
--- result:300

tips：建议不要再finally代码块中使用return，因为会覆盖try、catch里面的return。
    还有一种情况会导致异常丢失。 
    public int methodB6(int money) {
    try {
        methodA(money);
    } catch (SpecialException e) {
        throw new SpecialException("----wrong");  《==== 这个不会执行，没有提示method6 方法要 throws 异常。
    } finally {
        System.out.println("--- 第3步：catch完调用finally");
        return 200;
    }
}

可以对比
public void methodB6(int money) throws SpecialException {
    try {
        methodA(money);
    } catch (SpecialException e) {
        throw new SpecialException("----wrong");
    } finally {
        System.out.println("--- 第3步：catch完调用finally"); 这里没有return，所有catch里面的异常不会被丢弃。
    }
}
  • 异常类 
    public class Exception extends Throwable
    获取异常信息的两方法
public void printStackTrace() {
    printStackTrace(System.err);
}
public String getMessage() {
    return detailMessage;
}
    System.out.println("---- message"+e.getMessage());
e.printStackTrace();

结果：
---- message异常啦~~~
Exception.SpecialException: 异常啦~~~
    at Exception.ExceptionDemo.methodA(ExceptionDemo.java:14)
    at Exception.ExceptionDemo.methodB3(ExceptionDemo.java:26)
    at Exception.ExceptionDemo.main(ExceptionDemo.java:42)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

            c9588df3695f209d149d4bbae57fa7e5b6c.jpg

  • Exception 类，又分为两类
    运行时异常，runtimeException，也称uncheckException，编译器不检查它，即使没有try catch 或者throws ，还是会编译通过。
    受检查异常，Checked Exception，编译器会自己检查，当程序出现这类异常时，要么try catch，要么throws，不然报错。
     
  • 运行时异常由于不受检查，表示无法让程序恢复运行的异常，一旦出现，建议终止程序。

转载于:https://my.oschina.net/360yg/blog/3006245

Java作业之面向对象篇
m0_56423338的博客
07-25 814
面向对象
Java学习-狂神说-笔记-面向对象编程
qq_43104872的博客
03-16 670
Java学习-狂神说-笔记-面向对象编程 Java的核心思想就是OOP（面向对象编程） 1. 初识面向对象 面向过程&面向对象 面向过程思想（线性思维） 步骤清晰简单，第一步做什么，第二步做什么… 面对过程适合处理一些较为简单的问题 面向对象思想 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！ 对于描述复杂的事物，为了从宏观上把握、从
Java面向对象程序设计 实验四 异常处理
03-20
Java面向对象程序设计 实验四 异常处理
使用Java实现面向对象编程-->异常
qq_38171779的博客
04-16 421
异常是有Java应用程序抛出和处理的非严重错误，他可以分为Checked异常和运行时异常两大类。 Checked异常必须捕获或声明抛出，否则无法通过编译。运行时异常不要求必须捕获或声明抛出。 Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw和throws。 即使在try块、catch块中存在return语句，finally块中语句也会被执行。fina
狂神说java学习笔记---面向对象编程及异常
rzz65452064的博客
08-01 1360
面向对象编程 Java的核心思想就是oop 目录： 初始面向对象 方法回顾和加深 对象的创建分析 面向对象三大特性 抽象类和接口 内部类及OOP实战 初始面向对象 面向过程 & 面向对象 面向过程思想 步骤清晰简单，第一步做什么，第二步做什么… 面对过程适合处理一些较为简单的问题 面向对象思想 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
面向异常编程
bad0126的博客
05-26 269
在返回值时,返回false也可以看做是一种异常，那么我们可以自己编写package org.jsoft.test;public class User1 {public void verify(String username, String password) { if (!("ivan" .equals(username) && "ivan"...
Java面向对象编程——异常处理
weixin_55509293的博客
05-13 301
Java ——异常处理 在理想状态下，用户输入数据的格式永远都是正确的，选择打开的文件也一定存在，并且永远不会出现错误，但真实情况并非如此。 异常： 假如在一个Java程序运行期间出现了一个错误。这个错误可能是由于文件包含了了错误信息，或者网络连接出现问题造成的，等等，用户期望在出现错误时，程序能够采用一些理智的行为。如果由于出现错误而使得某些错做没有完成，程序应该： （1）返回一个安全状态，并能够让用户执行一些其他的命令 （2）允许用户保存所有操作的结果，并以妥善的方式终止程序 如果某个方法不能够采用正常
Java异常小结
08-04
在Java中，异常处理采用了一种面向对象的方式，通过创建特定的异常类来表示不同类型的错误，使得代码更加清晰、可维护。下面将详细讨论Java异常的分类、结构以及如何有效地使用它们。 首先，Java的异常都是从`...
java 面向对象总结
许诗宇的博客
06-10 1748
继承 简单的说，继承就是在一个现有类型的基础上，通过增加新的方法或者重定义已有方法（下面会讲到，这种方式叫重写）的方式，产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一，我们在使用JAVA时编写的每一个类都是在继承，因为在JAVA语言中，java.lang.Object类是所有类最根本的基类（或者叫父类、超类），如果我们新定义的一个类没有明确地指定继承自哪个基类，那么JAVA 就会默认为它是继承自Object类的。 我们可以把JAVA中的类分为以下三种： 类：使用c...
java面向对象期末复习题（含答案）
最新发布
m0_58881902的博客
06-25 3754
11、下面对异常说法不正确的是（ ） A）try/catch块为基本引发异常的组合 B）在捕获异常时,可以有多个 catch块 C）无论异常是否发生,finally块总会执行 D）try块和 finally 不能连用 12、通过继承（ ）类，用户可以创建自己的异常类。 A）Exception B）SystemException C）ApplicationException D）UserException
java必备——通过异常处理看面向对象
ESOO
04-03 2399
在看java视频的时候，看到异常处理的时候，我认识到自己编程上的一个缺憾，就是以前的错误处理他范范，我们应该针对不同的错误，做不同的处理，我拿出自己c#和vb的代码，看了看错误处理代码，发现，他们的格式很相似，想到面向对象和面向过程的对比，我想，咱们也许可以在这里，再挖掘一把！     在编写VB的时候，我作为一个小白，基本没有用过错误处理，心中的他是个很高大上的技术，而随着学习了c#，java
java面向对象-异常-总结
深情小建
07-30 877
异常： 是什么？是对问题的描述，将问题进行对象的封装 异常体系： Throwable |--Error |--Exception |--RuntimeException 异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性 也就是说可以被throw和throws关键字所操作 只有异常体系具备这个特点
Java面向对象异常学习
hua226的博客
03-24 434
Java面向对象之异常 一、异常 1.1 异常概述 异常：就是程序出现了不正常的情况 1.2 异常体系 Error：严重问题，不需要处理 Exception：称为异常类，它表示程序本身可以处理的问题 RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码 非RuntimeException：编译期必须处理的，否则程序不能通过编译，就更不能正常运行了 public class ExceptionDemo { public static void main(Stri
java面向对象程序设计(五)-----异常处理
hflyingheart的专栏
03-31 879
异常使用异常的方法：    try{}                           //捕获异常        catch(异常对象){}   //处理异常        [finally{}]                     //异常处理的统一出口异常类结构：       Throwable           ｜           ｜---
Java面向对象编程之异常处理机制
weixin_30853329的博客
06-02 143
一：Java的异常处理机制的优点： 1：把各种不同情况的异常情况分类，使用JAVA类来表示异常情况，这种类被称为异常类。把各种异常情况表示成异常类，可以充分的发挥类的可扩展性和可重用性。 2：异常流程的代码和正常流程的代码分离，提高了代码的可读性，简化了代码的结构。 3：可以灵活的处理异常，如果发生了异常程序员可以手动抛出异常，也可以交给调用者来处理异常。 二：Java虚拟机的方法调用栈 ...
Java面向对象编程错误
Luhuadeng的专栏
04-25 502
不知道代码应该放在那里 一个空类的代码如下所示，public 是类的访问修饰符号（目前可以忽略），class 是定义类的关键字，Rectangle是类的名字，接下来的{ } 中包含类的成员（目前没有任何成员）： public class Rectangle { } 现在我们来给他添加一个成员，表示长方形的宽度，宽度是数值，因此我们选择了int作为类型，width作为属性的名字。代码就编程这样...
Java面向对象三大类以及异常处理练习题
A__B__C__的博客
11-07 810
一.编程题: 要求: Person类有name,age,salary属性，要求实现至少两个构造方法，并且属性私有，提供对应的getter、setter。 覆写toString方法，要求在System.out.println()函数中传递Person对象能打印出三个属性值而不是对象地址。2.覆写toString方法，要求在System.out.println()函数中传递Person对象能打印出三...
java提供两种处理异常的机制_浅析Java异常处理机制
weixin_28335283的博客
02-24 325
关于异常处理的文章已有相当的篇幅，本文简单总结了Java的异常处理机制，并结合代码分析了一些异常处理的最佳实践，对异常的性能开销进行了简单分析。博客另一篇文章《[译]Java异常处理的最佳实践》也是关于异常处理的一篇不错的文章。请思考： 对比 Exception 和 Error ，二者有何区别？ 另外，运行时异常和一般异常有什么区别？Exception 和 Error 的区别首先，要明确的是 Ex...
Java中的常用异常处理
从零开始的Java编程
05-09 598
一、Java异常处理机制概述 1、Java虚拟机用方法调用栈来跟踪每个线程中一系列的方法调用过程。 2、方法中的代码块可能抛出异常，有如下两种处理办法： l 在当前方法中通过try…catch语句捕获并处理异常。例如：public void methodA(intmoney){ try{ //以下代码可能会抛出SpecialException if(--money <= 0) throw ne
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值