JavaSE——异常处理（异常简介、try-catch-finally、throws、throw）

最新推荐文章于 2023-06-04 00:41:09 发布
最新推荐文章于 2023-06-04 00:41:09 发布
阅读量254 收藏 3
点赞数
分类专栏： Java 文章标签： java 异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40467656/article/details/120215914
版权

第4节 异常处理

异常处理学习的目标：

  1. 明确说明是异常（重点）

  2. 能辨识出常见的异常及其含义（熟悉）

  3. 理解异常产生的原理（了解）

  4. 能处理异常（重点）

  5. 能够自定义异常（熟悉）

一、什么是异常？

异常是在程序中导致程序中断运行的一种指令流 。

例如，现在有如下的操作代码：

public class ExceptionDemo01{  

    public static void main(String argsp[]){  
        int i = 10 ;  
        int j = 0 ;  
        System.out.println("============= 计算开始 =============") ;  
        int temp = i / j ; // 进行除法运算  
        System.out.println("temp = " + temp) ;  
        System.out.println("============= 计算结束 =============") ;  
    }  
};  

运行结果：  
============= 计算开始 =============  
Exception in thread "main" java.lang.ArithmeticException: / by zero  
at ExceptionDemo01.main(ExceptionDemo01.java:6)

以上的代码在int temp = i / j ;位置处产生了异常，一旦产生异常之后，异常之后的语句将不再执行了，所以现在的程序并没有正确的执行完毕之后就退出了。

那么，为了保证程序出现异常之后仍然可以正确的执行完毕 ，所以要采用异常的处理机制。

二、处理异常

   如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下：

try{
    // 有可能发生异常的代码段
}catch(异常类型 对象名1) {
    //异常的处理操作
}catch(异常类型 对象名2) {
    //异常的处理操作
}...
finally{
    //异常的统一出口
}

下面分别来详细的介绍：

2.1 try+catch的处理流程

  1. 一旦产生异常，则系统会自动产生一个异常类的实例化对象；

  2. 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出；

  3. 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

下面这张图将过程解释的更加具体：

在这里插入图片描述

2.2 多异常捕获

   一段代码块可能产生多种异常时，需要对多种异常进行捕获，一般多异常捕获有三种方式：

方式一：分开处理：

package com.kaikeba.objectoriented.exceptionHandling;

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 处理多异常的格式 1：
 */
public class Demo2 {
    public static void main(String[] args) {
        haha();
        System.out.println("程序执行完毕，正常结束");
    }

    private static void haha() {
        try {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字：");
            int x = input.nextInt();
            System.out.println("请再输入一个数字：");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        }catch (InputMismatchException e) {
            System.out.println("必须是数字");
        }
    }
}

方式二：使用|运算符合并：

package com.kaikeba.objectoriented.exceptionHandling;

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 处理多异常的格式 2：了解
 */
public class Demo3 {
    public static void main(String[] args) {
        haha();
        System.out.println("程序执行完毕，正常结束");
    }

    private static void haha() {
        try {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字：");
            int x = input.nextInt();
            System.out.println("请再输入一个数字：");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch (ArithmeticException | InputMismatchException e) {
            System.out.println("输入有误");
        }
    }
}

方式三：合并为父类异常：

package com.kaikeba.objectoriented.exceptionHandling;

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 处理多异常的格式 3：常用
 */
public class Demo4 {
    public static void main(String[] args) {
        haha();
        System.out.println("程序执行完毕，正常结束");
    }

    private static void haha() {
        try {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字：");
            int x = input.nextInt();
            System.out.println("请再输入一个数字：");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch (RuntimeException e) {//多态
            System.out.println("输入有误");
        }
    }
}

多异常捕获的注意点：

  1. 捕获更粗的异常不能放在捕获更细的异常之前；

  2. 如果为了方便，则可以将所有异常都使用Exception进行捕获。

2.3 finally

在进行异常处理之后，在异常的处理格式中还有一个finally语句，此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码。除非软件关闭、电脑关机等强制方法。

观察如下代码：

package com.kaikeba.objectoriented.exceptionHandling;

public class Demo5 {
    public static void main(String[] args) {
        haha();
    }

    public static void haha() {
        try {
            System.out.println("1");
            System.out.println("2");
            System.out.println("3");
            System.out.println("4");
            return;
        }catch (Exception e) {
        }finally {
            System.out.println("锄禾日当午");
        }
    }
}

结果如下：

1
2
3
4
锄禾日当午

即使加了return;还是会执行finally里的代码。可以这样理解，return在返回返回值的时候，将返回值进行了一个备份，并做了一些准备工作然后才返回，在这个过程中，finally就执行了 ，所以效果如上所述。

那么这里就涉及到一个常问的面试题 ，查看如下两段代码：

package com.kaikeba.objectoriented.exceptionHandling;

public class Demo6 {
    public static void main(String[] args) {
        Person p = haha();
        System.out.println(p.age);
    }

    public static Person haha() {
        Person p = new Person();
        try {
            p.age = 18;
            return p;
        }catch(Exception e){
            return null;
        }finally {
            p.age = 28;
        }
    }

    static class Person{
        int age;
    }
}

结果为：28

package com.kaikeba.objectoriented.exceptionHandling;

public class Demo7 {
    public static void main(String[] args) {
        int a = haha();
        System.out.println(a);
    }

    public static int haha() {
        int a = 10;
        try {
            return a;
        }catch(Exception e){
            return 0;
        }finally {
            a = 20;
        }
    }

    static class Person{
        int age;
    }
}

结果为：10

解释：在return的时候，都是对返回的值或者对象进行了一个备份，在准备返回的过程中finally执行了，如果是引用数据类型，p里面保存的是地址，那么备份也备份了这个地址，finally对属性值修改后，通过地址依然可以访问到这个修改后的结果；但是如果是基本数据类型，a里面是值，return备份的是10这个值，finally虽然的确也修改了啊变为20，但是这个备份还是10 ，观察内存图可能更好理解一点：

在这里插入图片描述

在这里插入图片描述

补充： 唯一一种在代码中导致finally不执行的方法——System.exit(0);它的作用是正常退出程序，结束当前正在运行的java虚拟机。

package com.kaikeba.objectoriented.exceptionHandling;

public class Demo8 {
    public static void main(String[] args) {
        haha();
    }

    public static void haha() {
        try{
            int a = 10;
            int b = 0;
            System.out.println(a/b);
        }catch(Exception e) {
            //退出JVM
            System.out.println("出现了异常");
            System.exit(0);
        }finally {
            System.out.println("锄禾日当午");
        }
    }
}

结果如下：

出现了异常

没有执行finally里的代码，就结束了。

三、异常体系结构

异常指的是Exception类在Java中存在一个父类Throwable（可能的抛出）。

Throwable存在两个子类：

  1. Error：表示的是错误，是JVM发出的错误操作，只能尽量避免，无法用代码处理；

  2. Exception：一般表示所有程序中的错误，所以一般在程序中进行try-catch的处理。

在这里插入图片描述

可以看一下JDK API中文手册里的Exception里的子类：

在这里插入图片描述

其中需要特别注意的是RuntimeException类，它是非受检异常，也叫运行时异常，它只有在程序运行时才能知道是否会发生，事先无法检查出来，看一下它的子类：

在这里插入图片描述

   比如数学运算异常、数组索引超出范围异常等等，在代码编写时编译器是不能察觉的，只有运行时的确发生异常了才会出现。

   所以异常也可以细分为两类：

  1. 受检异常：

  2. 非受检异常/运行时异常：

RuntimeException与Exception的区别

注意观察如下方法的源代码：

Integer类：public static int parseInt(String text throws NumberFormatException

此方法抛出了异常，但使用时却不需要进行try...catch捕获处理，原因：

因为 NumberFormatException 并不是Exception的直接子类，而是RuntimeException的直接子类，只要是RuntimeException的子类，则表示程序在操作的时候可以不必使用try-catch进行处理，如果有异常发生，则由JVM进行处理。当然，也可以通过try catch处理。

四、throws关键字

在程序中异常的基本处理已经掌握了，但是随异常一起的还有一个称为throws关键字，此关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。

格式：
    返回值 方法名称() throws Exception{
    
    }

package com.kaikeba.objectoriented.exceptionHandling;

import java.io.IOException;

public class Demo9 {
    public static void main(String[] args) throws IOException {
        shutdown("");
    }
    
    public static void shutdown(String text) throws IOException {
        Runtime.getRuntime().exec(text);
    }

    public static void sum(String s1, String s2) {
        try {
            int sum = Integer.parseInt(s1) + Integer.parseInt(s2);
            System.out.println("和是：" + sum);
        }catch(NumberFormatException e) {
            
        }
    }
}

异常是应该抛出去还是处理，应该站在哪个角度进行思考：

如果是因为传参导致的异常，应该通过throws将异常抛出去 。

五、throw关键字

throw关键字表示在程序中人为的抛出一个异常 ，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。

看下面这个例子：

package com.kaikeba.objectoriented.exceptionHandling;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0 || age>180) {
            RuntimeException e = new RuntimeException("年龄不合理");
            throw e;
        }else {
            this.age = age;
        }
    }
}


package com.kaikeba.objectoriented.exceptionHandling;

public class Demo10 {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(-1);
    }
}

结果如下：

Exception in thread "main" java.lang.RuntimeException: 年龄不合理
  at com.kaikeba.objectoriented.exceptionHandling.Person.setAge(Person.java:21)
  at com.kaikeba.objectoriented.exceptionHandling.Demo10.main(Demo10.java:8)

Process finished with exit code 1

   因为年龄如果输入不合理，我们就应该告诉执行者年龄有问题，不能像之前一样只是给它赋一个默认值，但是这里又没有任何异常的代码出现，所以为了逻辑上合理，将不合逻辑的年龄手动的抛出异常。

六、自定义异常类（了解）

  • 编写一个类，继承Exception，并重写一参构造方法 即可完成自定义受检异常类型。

  • 编写一个类，继承RuntimeExcepion，并重写一参构造方法 即可完成自定义运行时异常类型。

例如：

class MyException extends Exception{
    public MyException(String msg){    //继承Exception，表示一个自定义异常类
        super(msg);    //调用Exception中有一个参数的构造
    }
}

自定义异常可以做很多事情， 例如：

class MyException extends Exception{
    public MyException(String msg){
        super(msg) ;
        //在这里给维护人员发短信或邮件， 告知程序出现了BUG。
    }
}

   上述throw抛出异常的例子可以结合自定义类，就是将`RuntimeException`改为自定义的异常类，代码如下：

package com.kaikeba.objectoriented.exceptionHandling.MyExpection;

public class AgeRuntimeException extends RuntimeException{
    {
        //给程序员发短信
    }
    public AgeRuntimeException(String message) {
        super(message);
    }
}

package com.kaikeba.objectoriented.exceptionHandling.MyExpection;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0 || age>180) {
            AgeRuntimeException e = new AgeRuntimeException("年龄不合理");
            throw e;
        }else {
            this.age = age;
        }
    }
}

package com.kaikeba.objectoriented.exceptionHandling.MyExpection;

public class Demo {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(-1);
    }
}

结果如下：

Exception in thread "main" com.kaikeba.objectoriented.exceptionHandling.MyExpection.AgeRuntimeException: 年龄不合理
  at com.kaikeba.objectoriented.exceptionHandling.MyExpection.Person.setAge(Person.java:21)
  at com.kaikeba.objectoriented.exceptionHandling.MyExpection.Demo.main(Demo.java:6)

Process finished with exit code 1

七、异常处理常见面试题

1. try-catch-finally中哪个部分可以省略？
答：catch和finally可以省略其中一个，catch和finally不能同时省略。
注意：格式上允许省略catch块，但是发生异常时就不会捕获异常了，在开发中也不会这样去写代码。

2. try-catch-finally中，如果catch中return了，finally还会执行吗？
答：finally中的代码会执行。
详解：
    执行流程：
        1. 先计算返回值，并将返回值存储起来，等待返回；
        2. 执行finally代码块；
        3. 将之前存储的返回值，返回出去。 
    需注意：
        1. 返回值是在finally运算之前就确定了，并且缓存了，
           不管finally对该值做任何的改变，返回的值都不会改变；
        2. finally代码中不建议包含return，
           因为程序会在上述的流程中提前退出，也就是说返回的值不是try或catch中的值；
        3. 如果在try或catch中停止了JVM，则finally不会执行，例如停电，或通过如下代码退出：
            JVM：System.exit(0);
slight smile
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE进阶-04-异常处理.pdf
09-10
2020动力节点老杜javaSE进阶班-异常处理04教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
JavaSE_2_异常处理
02-09
异常的处理流程，异常类的继承关系，异常的统一出口，throws关键字，throw关键字，异常的标准处理结构，RuntimeException与Exception的区别，自定义异常类，assert关键字，Eclipse debug
Java基础(四):异常处理
Justin_Andyson的博客
04-04 3122
Java中异常处理问题多运用于以下场景:外部资源调用,用户输入验证,数据库操作,系统运行时错误,多线程编程
java中处理异常的方法
wdnn_wza的博客
06-15 2902
处理checked异常:throws,throw;try-catch-finally 处理unchecked异常
Java中异常处理方式
qq_43526183的博客
12-10 3936
Java中异常处理方式
JAVA异常处理（三种异常处理机制）
美好的事情即将发生！
07-14 7024
异常是程序在编译或执行的过程中可能出现的问题，语法错误不算在异常体系提前处理异常，程序会更加安全Error： 系统级别问题、JVM退出等，代码无法控制Exception： Java.lang包下，称为异常类，它表示程序本身可以处理的问题 Runtime Exception及其子类： 运行时异常，编译阶段不会报错（如空指针，数组索引越界异常） 除Runtime Exception之外所有异常：
一次搞懂Java异常处理(超详细!!!)！
weixin_53622554的博客
03-17 5116
Java标准库中提供了非常多表的异常类型，用来表达各种异常情况，然而在真实开发中，这些异常并不能完全满足我们的需求，因为标准库的异常往往表达的是技术层面，而不是业务层面，像账号密码错误这种情况，用标准库的异常就不太合适，所以在开发中我们会自定义异常类型，来表达符合我们业务的异常情况。finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法放入finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
JavaSE 异常处理.pdf
07-23
在Java中，我们可以使用try-catch语句来捕获异常。在try块中编写可能会引发异常的代码，在catch块中编写处理异常的代码。例如： try { //可能会抛出异常的代码 } catch (ExceptionType e) { //处理异常的代码 } ...
javase-学习笔记.pdf
11-28
javase-学习笔记.pdf
JavaSE专题-Set集合.doc
06-03
JavaSE专题-Set集合
Java异常处理机制try catch流程详解
08-19
主要介绍了Java异常处理机制try catch流程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
终于有人把Java异常处理方法给总结出来了，吃透这篇足够
the shy
05-04 2152
这篇文章是我之前学过的基础总结，希望对大家有所帮助！我们在做程序开发时候，都想着把代码写的完美无瑕（不大可能）客户输入的数据格式读取文件是否存在网络是否始终保持通畅我们把这类问题，归结为异常！异常概念：在Java语言中，将程序执行中发生的不正常情况称为异常（异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行）Java中异常分为两类Error：java虚拟机无法解决的严重问题（JVM系统内部错误、资源耗尽），一般没办法编写针对性代码进行处理（处理不了。
java中的异常处理
weixin_45581692的博客
07-17 1万+
异常的作用增强程序的健壮性。java中异常以什么形式存在？异常在java中以类的形式存在，每一个异常类都可以创建异常对象。JVM执行到某一处觉得有异常，会new异常对象，并且将new的异常对象抛出，打印输出信息到控制台了。如异常对应的现实生活火灾（异常类）2008年8月8日，小明家着火了（异常对象）2008年8月9日，小红家着火了（异常对象）异常体系结构注意所有异常都是在运行阶段发生的，因为只有程序运行阶段才可以new对象，因为异常的发生就是new异常对象。第一种方式。......
java中常见的异常以及异常的处理方式是什么？
qq_57632597的博客
03-07 794
java中的异常
Java异常及其处理（超全讲解）
m0_71469414的博客
05-05 1352
如果finally块在catch块之前，当try块中的代码抛出异常时，程序就会直接跳转到finally块中执行，而不是执行catch块中的代码。，可以打印出异常的完整堆栈信息，包括异常的类型、消息、异常出现的位置以及异常发生时调用栈的信息。这个方法会在控制台输出异常的完整信息，便于我们查看异常的类型和异常发生时的调用栈，从而更好地定位和解决问题。而非运行时异常则必须在代码中进行显式的处理，否则会导致程序的终止。try块中包含可能会出现异常的代码，catch块中处理异常，finally块中释放资源。
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异常问题三种处理方式
天才小汪汪
04-29 6374
1.抛出异常有两种方式 第一种是在方法上throw 第二种是使用try-catch语句，在catch中new throw出去 一般会在controller层将service层的异常try-catch，将异常发给前端 2.异常处理分三类 第一类，特殊异常，即自己业务上的特殊异常，需要特别处理的，直接在catch中将该异常处理吃掉。比如有个业务需要访问一个鉴权的接口，当第一次鉴权不成功时，捕...
java异常处理方式
qq_45976767的博客
04-18 4826
java异常处理方式 java通过面向对象的方式进行异常处理，一旦方法出现异常，系统自动根据该异常对象寻找合适的异常处理器（Exception Handler）来处理异常，把各种不同的异常进行分类，并提供了良好的接口。 java中，每个异常都是一个对象，它是Throwable类或其他子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。 java的异常处理是通过5个关键词来实现的，throw、try、catch、finally、t
如何使用Java异常处理来优雅地处理各种异常情况？
网络技术联盟站
06-04 350
异常处理是Java编程中非常重要的一部分。通过使用Java异常处理机制，我们可以更好地调试和排除代码中的错误，提高代码的可读性、可维护性和稳定性。在编写Java代码时，我们应该尽可能地遵循最佳实践，例如使用多个catch块处理不同类型的异常、始终使用finally块释放资源、尽量避免使用throws关键字等。
try catch try异常catch还会执行吗
最新发布
08-10
引用中提到，try-catch块用于处理异常。在try块中，如果发生了异常，会生成对应的异常对象并传递给catch块进行处理。catch块中的代码会执行处理异常的操作。所以，当发生异常时，try块中异常出现的那行代码之后的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值