文档开发者中心
我的

学习Java异常,吃透这篇足够

一、前言

这篇技术博客是我复习尚硅谷JavaSE教程做的笔记总结,方便大家的学习同时也方便自己。博客内容非复制粘贴,纯手写。如果对你有帮助,欢迎点赞评论收藏!

二、异常概述及异常体系结构

1.概述

我们在做程序开发时候,都想着把代码写的完美无瑕(不大可能),但是真实情况是在系统运行代码时,仍然会遇到一些问题,不能靠代码避免,比如:

  • 客户输入的数据格式

  • 读取文件是否存在

  • 网络是否始终保持通畅

我们把这类问题,归结为异常!

异常概念:在Java语言中,将程序执行中发生的不正常情况称为异常(异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行)

Java中异常分为两类:

  1. Error:java虚拟机无法解决的严重问题(JVM系统内部错误、资源耗尽),一般没办法编写针对性代码进行处理(处理不了)


public class ErrorTest {

    public static void main(String[] args) {

        //1.栈溢出java.lang.StackOverflowError

        main(args);

        

        //2.堆溢出:java.lang.OutOfMemoryError

        Integer[] arr = new Integer[1024 * 1024 * 1024];

    }

}


2.Exception:因编程错误或偶尔的外在因素导致的一般性问题,可以使用针对性的代码进行处理(空指针访问,试图读取不存在的文件,网络连接中断,数组角标越界等)

注意:我们平常将Error和Exception都称作广义上的异常,但是由于我们不处理Error,所以我们平时在开发中提到的异常一般指的是Exception,我们说的异常处理指的就是狭义上的异常:Exception,所以此博客主要讲解的异常处理针对的是Exception

2.异常体系结构

捕获错误最理想的是编译期间,但有的错误只在运行期间发生,比如:除数为0、数组下标越界等

Exception分类:编译时异常(需要处理)、运行时异常(一般不处理)

体系结构图如下:
异常的顶级父类是 java.lang.Throwable,其下有两个子类:java.lang.Error 与 java.lang.Exception,平常所说的异常指java.lang.Exception 。

三、异常处理方式(两种)

Java采用的异常处理机制,是将异常处理的程序代码集中在一起,与正常的程序代码分开,使得程序简洁、优雅,并易于维护。其实异常处理并非真正意义上将异常代码改正,修改代码操作还是需要开发人员自己去做!

异常的处理:抓抛模型
过程一(抛):程序在正常执行过程中,一旦出现异常,就会在异常代码出生成一个对应异常类的对象,并将此对象抛出。一旦抛出对象以后,其后的代码就不再执行。
过程二(抓):可以理解为异常处理的方式:①try-catch-finally ②throws

关于异常对象的产生:

  • 系统自动生成的异常对象

  • 手动生成一个异常对象,并抛出(throw)

1.方式一:try-catch-finally

使用格式:

try{

...... //可能产生异常的代码

}

catch(ExceptionName1 e){

...... //当产生ExceptionName1型异常时的处置措施

}

catch(ExceptionName2 e){

...... //当产生ExceptionName2型异常时的处置措施

}

......

finally{

...... //无论是否发生异常,都无条件执行的语句

}

注意:finally为可选结构,是否使用取决于自己



代码展示与说明:


/**

 * 说明:

 * 1.finally是可选的

 * 2.使用try将可能出现异常的代码包装起来,在执行过程中,一旦出现异常,就会生成一个对应异常类的对象

 *   根据此对象的类型,去catch中进行匹配

 * 3.一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理,一旦处理完成就跳出

 *   当前的try-catch结构(在没写finally情况下),继续执行其后的代码

 * 4.catch中的异常类型如果没有子父类关系,则先声明谁都无所谓

 *   catch中的异常类型如果满足子父类关系,则要求子类一定声明在父类的上面。否则报错

 * 5.常用的异常对象处理的方式:①String getMessage() ②printStackTrace()

 * 6.在try中声明的变量,在出了try结构后,不能再被调用

 */

public class ExceptionTest {

    public static void main(String[] args) {

        String str = "123";

        str = "abc";

        int num = 0;

        try {

            num = Integer.parseInt(str); //可能出现异常的代码

            System.out.println("hello------1");

        }catch (NullPointerException e){

            System.out.println("出现空指针异常了,不要急");


        }catch (NumberFormatException e){

            //System.out.println("出现数值转换异常了,不要急");

            //System.out.println(e.getMessage());

            e.printStackTrace();

        }catch (Exception e){

            System.out.println("出现异常了,不要急");

        }

        System.out.println(num);

        System.out.println("hello------2");

    }

}


上述代码中只使用了try-catch结构,并没有使用finally,接下来我们学习一下finally的使用细节:

  1. finally中声明的是一定会被执行的代码,即使catch中有出现异常,
    try中有return语句,catch中有return语句等情况

  2. 像数据库连接、输入输出流、网络编程Socket等资源,JVM是不能自动回收的,
    我们需要自己手动进行资源释放。此时资源释放需要声明在finally中。
    为了防止释放之前的代码有异常,导致资源不被释放, 所以放在finally中

  3. try-catch-finally可以嵌套使用


//不论是catch中有异常,还是catch中有return,我们的finally代码块一定会执行!

public class FinallyTest {

    public static void main(String[] args) {

        try {

            int a = 10;

            int b = 0;

            System.out.println(a / b);

        }catch (ArithmeticException e){

            //e.printStackTrace();

            int[] arr = new int[10];

            System.out.println(arr[10]); //回报数组越界异常,但是没有处理

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            System.out.println("就算你报异常,我也一定要执行!");

        }

    }

}



我们在开发过程中对于运行时异常不用try-catch处理

也无法真正意义上解决,我们得去改代码。所以———运行时异常,不用try-catch


但是对于编译时异常需要对它try-catch,否则连编译期都过不去,更别说运行了!

编译过去了,如果运行正确就ok。如果运行出错,就是将异常延迟到运行期出现!

相当于我们使用try-catch结构将编译时异常变成运行时异常!


体会1:使用try-catch-finally处理编译时异常,使得程序在编译就不在报错但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常延迟到运行时出现。

体会2:开发中,由于运行时异常比较常见,所以我们通常就不针对运行时异常编写try-catch-finally,针对于编译时异常一定要考虑异常的处理(进行代码修改)!

2.方式二:throws

该方式写在方法的声明处,指明此方法执行时可能会抛出的异常类型,一旦当方法体执行时出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后异常类型时就会被抛出。异常代码后续的代码不再执行!

代码演示:

public class ExceptionTest2{

    public static void main(String[] args){

        //如果抛给main方法,就需要try-catch处理了!

        //不能再向上抛出了

        try {

            method2();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }


    public static void method2() throws IOException{

        method1();

    }


    public static void method1() throws IOException {

        File file = new File("hello.txt"); //文件找不到,会报异常

        FileInputStream fis = new FileInputStream(file);


        int data = fis.read();//异常

        while (data != -1){

            System.out.println((char)data);

            data = fis.read(); //异常

        }

        fis.close();//异常

    }

}


体会:两种异常处理方式的区别?

  • try-catch-finally真正的将异常处理(并不是修改代码修正异常)

  • throws方式(甩锅)只是将异常抛给方法的调用者,并没有真正将异常处理掉!

注意:子类重写的方法抛出的异常类型不大于(<=)父类被重写方法抛出的异常类型

四、如何选择处理异常方式

我们在开发中处理异常以该选择这两种方式中的哪一种呢?

  • 如果父类中被重写的方法没有throws方式处理异常,则子类重写的方法也不能够使用throws(原因看上述注意),意味着子类重写的方法中有异常,就必须使用try-catch-finally方式处理!

  • 执行的方法a中,先后又调用了另外的几个方法,这几个方法是递进关系执行的。建议这几个方法使用throws方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理

二次理解:我们现在的两种异常处理方式,指的是代码执行之前可能会出现问题,我们提前做一个预案,万一出现问题了我们该怎么办!比如:弹出一个提示框。当然我们同时要明白:异常处理并不是真正意义上讲异常解决!异常处理机制不会帮助我们修正代码,还是需要我们自己处理修改异常代码!

五、手动抛出异常(throw)

关于异常对象的产生:

  1. 系统自动生成的异常对象

  2. 手动生成异常对象并抛出(throw)

代码展示:

public class StudentTest {

    public static void main(String[] args) {

        try {

            Student s = new Student();

            //数据非法,需要处理异常对象

            //调用此方法进入到catch代码块中

            s.regist(-1001);

        } catch (Exception e) {

        //控制台输出:您输入的数据非法

            System.out.println(e.getMessage());

        }

    }

}


class Student{

    private int id;

    public void regist(int id) throws Exception {

        if (id > 0){

            this.id = id;

        }else {

            //手动抛出异常对象

            throw new Exception("您输入的数据非法!");

        }

    }

}


六、自定义异常类

我们上述见到的异常都是Java提供好的(官方的),我们当然也可以自己去自定义异常:

如何自定义异常类?

  • 1.自定义类继承于现有的异常类结构:RuntimeException、Exception

  • 2.提供全局常量:serialVersionUID 序列版本号,用于标识类

  • 3.提供重载的构造器

代码展示:

//自定义异常类

public class MyException extends RuntimeException{

    static final long serialVersionUID = -7034897190745766939L;


    public MyException() {


    }

    public MyException(String msg) {

        super(msg);

    }

}


//学生类

class Student{

    private int id;


    public void regist(int id){

        if (id > 0){

            this.id = id;

        }else {

            throw new MyException("不能输入负数");

        }

    }

}


//测试类

class Test{

    public static void main(String[] args) {

        try {

            Student s = new Student();

            s.regist(-1001);


        } catch (Exception e) {

            System.out.println(e.getMessage());

        }

    }

}


七、异常处理总结

5个关键字几乎就能涵盖异常处理的所有内容了!

面试题:throw和throws区别?

  1. throw表示抛出一个异常对象,生成异常对象的过程。声明在方法体内

  2. throws属于异常处理的一种方式,声明在方法的声明处


作者:Coder Xu

原链接:https://blog.csdn.net/weixin_46594796/article/details/113442988?utm_medium=distribute.pc_category.none-task-blog-hot-1.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-1.nonecase&request_id=

点赞
收藏
回复
分享
举报
浏览1078 发布于2021-02-09 01:52未知归属地
全部评论
最多点赞
最新发布
最早发布
暂无评论
暂无评论
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要发帖子

目录 收起
一、前言
二、异常概述及异常体系结构
1.概述
2.异常体系结构
三、异常处理方式(两种)
1.方式一:try-catch-finally
2.方式二:throws
四、如何选择处理异常方式
五、手动抛出异常(throw)
六、自定义异常类
七、异常处理总结
了解社区公约,与您携手共创和谐专业的开发者社区。