8. Java 基础：异常

作者: 架构小白菜 | 来源:发表于2020-12-12 21:31 被阅读0次

一、异常继承体系
二、发生异常到时候，程序的执行特征：
三、异常与错误的区别
四、抛出异常 throw
五、声明异常 throws
六、捕获异常 try…catch…finally
七、 try…catch…finally 异常处理的组合方式
八、异常在方法重写中细节
九、 Throwable类中的常用方法
十、 try和finally中都有return语句，执行哪一个return？
十一、自定义异常

一、异常继承体系

异常是程序运行过程中出现的错误。Java 把异常当作对象来处理，把异常信息封装成了一个类，并定义一个基类 java.lang.Throwable 作为所有异常的超类。
Throwable : 它是所有错误与异常的超类（祖宗类）,有两个子类Error 和`Exception
Error: 错误。程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，**Java虚拟机（JVM）一般会选择线程终止**。Exception `: 异常。程序本身可以处理的异常，程序中应当尽可能去处理这些异常。
RuntimeException : 运行期异常, JAVA程序运行过程中出现的问题
CheckableException: 编译时异常或者可检查异常, 是除了`RuntimeExecption(及其子类)之外的所有 Exception

运行时期异常:
方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
运行时期异常一旦发生,需要程序人员修改源代码.
编译时异常: 必须在编译前处理，否则无法通过编译

二、发生异常到时候，程序的执行特征：

我们的代码，从发生异常的地方，开始被一分为二
在异常发生之前的代码，都可以正常运行，之后的代码不会执行
当异常发生的时候，这个异常被** jvm 所捕获，并将这个异常的所有相关信息，创建为一个异常对象，然后将该异常对象的信息输出到控制台**（执行的是虚拟机默认的异常处理代码）
终止当前程序

三、异常与错误的区别

异常：指程序在编译、运行期间发生了某种异常(XxxException)，我们可以对异常进行具体的处理。若不处理异常，程序将会结束运行。
错误：指程序在运行期间发生了某种错误(XxxError)，Error 错误通常没有具体的处理方式，程序将会结束运行。Error错误的发生往往都是系统级别的问题，都是jvm所在系统发生并反馈给jvm的。我们无法针对处理，只能修正代码。

四、抛出异常 throw

在 java 中，提供了一个throw关键字，它用来抛出一个指定的（Throwable类型）异常对象.
一般会用于程序出现某种逻辑时，程序员主动抛出某种特定类型的异常
具体步骤：
创建一个异常对象, 封装一些提示信息(信息可以自己编写).
通过关键字throw, 将这个异常对象告知给调用者.
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
使用格式：throw new 异常类名(参数);

throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
//具体范例：
public static void main(String[] args) {
    String s = "abc";
    if(s.equals("abc")) {
        throw new NumberFormatException();
    } else {
        System.out.println(s);
    }
    //function();
}

注意事项：
如果抛出的异常对象属于可检查的异常，必须在该方法头部，声明抛出此异常, 即: throws 要抛出的异常类型
其次，对于抛出可检查的异常，还必须与方法的异常列表中的异常兼容
如果父类方法声明了异常列表：
子类可以不声明异常列表
子类方法有自己异常列表时，必须保证，子类的异常列表所包含的异常类型，与父类中所包含的异常类型兼容

五、声明异常 throws

声明：将问题标识出来，报告给调用者
throws 是方法可能抛出异常的声明, 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明。
对于声明了会抛出可检查异常的方法, 就意味着这个方法会产生可检查异常，所以，一旦调用该方法就必须对该方法做异常处理
throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。
声明异常格式：修饰符返回值类型方法名(参数) throws <异常列表> { }

public static void function() throws NumberFormatException{
        String s = "abc";
        System.out.println(Double.parseDouble(s));
    }

    public static void main(String[] args) {
        try {
            function();
        } catch (NumberFormatException e) {
            System.err.println("非数据类型不能转换。");
        }
}

六、捕获异常 try…catch…finally

捕获：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理
捕获异常格式：

try {
    //需要被检测的语句。
}
catch(异常类 e) { //try中抛出的是什么异常，在括号中就定义什么异常类型。
    //异常的处理语句。
}
finally {
    //一定会被执行的语句。
}
//try：该代码块中编写可能产生异常的代码。
//catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
//finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

某个函数或某段程序块不管会不会，有没可能抛出异常，都可以加try{...}catch{...}去捕捉它。

异常处理流程：

1.首先，当异常在try代码块中发生的时候，虚拟机首先捕获这个异常，创建一个异常对象(包含本次异常的所有详细信息)
2.虚拟机会把这个异常，抛出给catch代码块（类似于方法调用，虚拟机会调用catch代码块中，处理异常的代码）
3.执行catch代码块，中的处理异常的代码
4.没有终止我们应用程序，而是从catch语句之后的代码开始，继续执行我们的应用程序

在try语句块中，一旦发生异常，我们的代码仍然被一分为二
1. 在异常发生之前带代码都正常运行
2. 在异常发生之后的代码，不会执行，而是直接跳转到我们自己处理异常的catch代码块中

七、try…catch…finally 异常处理的组合方式

try catch finally组合：检测异常，并传递给 catch 处理，并在 finally 中进行资源释放。

即使在finally代码块执行了return语句，finally代码块中的代码，仍然会执行
特殊情况: 走到finally之前 JVM 退出了,就不会执行finally了
finally在开发中的应用：用于释放资源

try catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对异常进行捕获处理
多个try catch组合当可能有多种类型的异常发生的时候，我把可能产生某异常类型的代码分开，分别放在不同的try-catch代码块中

执行特征是：
1. 每个try-catch中是否抛出异常，相互独立的
2. 在实际执行的时候，每一个try-catch代码块可能都产生异常。
实际开发的时候，一般来讲：
1. 效率角度，try 块中方的代码越少越好
2. 开发的时候，会将相关的异常，放在同一个 try 块
a.相关异常：一个连续的流程中，可能发生的一系列异常
b. 所以一系列相关的流程中，一旦前一步出现了异常，就会导致，即使后面的流程正常执行，其实也已经没有意义了

一个try 多个catch组合: 对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。

这种异常处理方式，要求多个catch中的异常不能相同
若catch中的多个异常之间有子父类异常的关系，那么先写子类异常类型，再写父类异常类型
当发生异常的时候，最多执行一个catch分支的代码

public class Demo {
    public static void main(String[] args) {
        try{
            int i = 10;
            //可能发生异常的语句
            int j = i / 0;
            System.out.println("try after exception");
            //空指针异常
            int[] a = null;
            System.out.println(a[0]);
            //数组越界异常
            int[] b = {1, 2, 3};
            System.out.println(b[3]);
        }catch (ArithmeticException e) {
            System.out.println("发生了除0异常");
        } catch (NullPointerException | ArrayIndexOutOfBoundsException e) { //一个catch分支处理多种类型的异常
            System.out.println("发生了数组异常");
        }
    }
}

try finally 组合: 对代码进行异常检测，检测到异常后因为没有catch，所以一样会被默认 jvm 抛出。异常是没有捕获处理的。但是功能所开启资源需要进行关闭，所以 finally只为关闭资源

八、异常在方法重写中细节

子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明。

class Fu {
    public void method () throws RuntimeException {
    }
}

class Zi extends Fu {
    public void method() throws RuntimeException { }  //抛出父类一样的异常
    //public void method() throws NullPointerException{ } //抛出父类子异常
}

    当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。

class Fu {
    public void method () throws NullPointerException, ClassCastException{
    }
}
class Zi extends Fu {
    public void method()throws NullPointerException, ClassCastException { }
    public void method() throws NullPointerException{ } //抛出父类异常中的一部分
    public void method() throws ClassCastException { } //抛出父类异常中的一部分
}

当被覆盖的方法没有异常声明时，子类覆盖时无法声明异常的。

九、Throwable类中的常用方法

getCause()：返回抛出异常的原因，即异常提示信息。如果 cause 不存在或未知，则返回 null。
getMessage()：返回异常的消息信息，即该异常的名称与详细信息字符串
printStackTrace()：在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置

十、try和finally中都有return语句，执行哪一个return？

首先要确定的一点是，不管有木有出现异常，finally块中代码都会执行
当try和catch中有return时，finally仍然会执行；
finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

问：如果try和finally语句里面都有return，会执行哪一个呢？
首先，在程序没有异常的情况下，首先执行到try里面的语句，但是只执行到了return里面的****expression，expression首先存放在操作数栈顶，然后复制到局部变量区，并没有执行返回语句return（执行返回语句通常意味着程序执行结束）。然后执行finally，当执行到finally里面的return时候，会将return语句执行完整，此时程序已经有了返回值，因为，执行结束。

总结：执行try块，执行到return语句时，先执行return的语句，但是不返回到main 方法，接下来执行finally块，遇到finally块中的return语句，执行,并将值返回到main方法，这里就不会再回去返回try块中计算得到的值

十一、自定义异常

如果Java没有提供你需要的异常，则可以自定义异常类。
编译时异常继承Exception，运行时异常继承 RuntimeException
格式：

Class 异常名 extends Exception{ //或继承RuntimeException
    public 异常名(){
    }
    public 异常名(String s){
        super(s);
    }
}

示例：

需求描述：
定义Person类，包含name与age两个成员变量。
在Person类的有参数构造方法中，进行年龄范围的判断，若年龄为负数或大于200岁，则抛出NoAgeException异常，异常提示信息“年龄数值非法”。
要求：在测试类中，调用有参数构造方法，完成Person对象创建，并进行异常的处理。

//自定义异常类
class NoAgeException extends Exception{
    NoAgeException() {
        super();
    }

    NoAgeException(String message)  {
        super(message);
    }
}

//Person类
class Person{
    private String name;
    private int age;
    Person(String name,int age) throws NoAgeException   {
        //加入逻辑判断
        if(age<0 || age>200)        {
            throw new NoAgeException(age+",年龄数值非法");
        }
        this.name = name;
        this.age = age;
    }
    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。
    public String toString()    {
        return "Person[name="+name+",age="+age+"]";
    }
}

//测试类
class ExceptionDemo{
    public static void main(String[] args) {
        try {
            Person p = new Person("xiaoming",20);
            System.out.println(p);
        }
        catch (NoAgeException ex){
            System.out.println("年龄异常啦");
        }
        System.out.println("over");
    }
}

总结一下，构造函数到底抛出这个NoAgeException是继承Exception呢？还是继承RuntimeException呢？
继承Exception，必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行。
继承RuntimeExcpetion,不需要throws声明的，这时调用是不需要编写捕获代码的，因为调用根本就不知道有问题。一旦发生NoAgeException，调用者程序会停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码。

8. Java 基础：异常

目录：

一、异常继承体系

二、发生异常到时候，程序的执行特征：

三、异常与错误的区别

四、抛出异常 throw

五、声明异常 throws

六、捕获异常 try…catch…finally

七、try…catch…finally 异常处理的组合方式

八、异常在方法重写中细节

九、Throwable类中的常用方法

十、try和finally中都有return语句，执行哪一个return？

十一、自定义异常

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

程序员