Java：异常-CSDN博客

本文链接：https://blog.csdn.net/hellg/article/details/134360798

基本概念

在Java中将程序执行过程中发生的不正常行为称为异常

常见异常

1.算术异常

这一行告诉你异常发生的对应程序和位置

当程序出现异常后，将不会继续执行异常后的代码

这里异常后的abcd不会再打印

2.数组越界异常

3.空指针异常

异常体系结构

上图中Exception代表异常，error代表错误

error是如何发生的？

比如下面的代码，func自己调用自己，main方法调用func，不停递归导致栈溢出error

1. Throwable ：是异常体系的顶层类，其派生出两个重要的子类 , Error 和 Exception

2. Error ：指的是 Java 虚拟机无法解决的严重问题，比如： JVM 的内部错误、资源耗尽等 ，典型代表： StackOverflowError 和 OutOfMemoryError ，一旦发生回力乏术。

3. Exception ：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception 。

异常分类

1.运行时异常（非受查异常）

RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException。

注意：编译时出现的语法性错误，不能称之为异常。例如将 System.out.println 拼写错了 , 写成了 system.out.println. 此时编译过程中就会出错 , 这是 " 编译期 " 出错。而运行时指的是程序已经编译通过得到class 文件了 , 再由 JVM 执行过程中出现的错误 .

2.编译时异常（受查异常）

顾名思义，在程序编译时发生的异常

经典的克隆异常

为什么这里的clone会报红呢？因为main方法在调用clone的时候没有跟着抛出

CloneNotSupportedException

异常处理

防御式编程

1.LBYL：事前防御型

在每次进行操作时都要检查是否出现错误

        boolean ret = false;
        ret = 登陆游戏();
        if (!ret) {
            处理登陆游戏错误;
            return;
        }
        ret = 开始匹配();
        if (!ret) {
            处理匹配错误;
            return;
        }
        ret = 游戏确认();
        if (!ret) {
            处理游戏确认错误;
            return;
        }
        ret = 选择英雄();
        if (!ret) {
            处理选择英雄错误;
            return;
        }
        ret = 载入游戏画面();
        if (!ret) {
            处理载入游戏错误;
            return;
        }

缺陷：流程和错误处理都放在一起显得代码混乱

2.EAFP：事后认错型

先操作，有问题再处理

try {
    存放可能存在异常的代码
...
} catch (捕获具体的异常) {
    处理该异常;
} finally{

}

优势：流程和错误处理分开，程序员看着比较清晰

异常的抛出(throw)

处理异常的前提就是抛出异常，抛出方式有多种

1.程序触发

2.通过关键字throw抛出

而上面提到的算术异常等都是由JVM抛出的

异常的捕获

throws

throw和throws的区别：

throws使用在方法的声明之后，作用: 告诉方法调用者，调用这个方法可能会抛出一个异常

throw就是抛自定义异常

⚠声明的异常必须是Exception或Exception的子类

⚠如果方法内部抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开。如果多个异常类型具有父子类型，直接声明父类就行了

public class Config {
    File file;

    // public void OpenConfig(String filename) throws IOException,FileNotFoundException{
    // FileNotFoundException 继承自 IOException
    public void OpenConfig(String filename) throws IOException {
        if (filename.endsWith(".ini")) {
            throw new IOException("文件不是.ini文件");
        }
        if (filename.equals("config.ini")) {
            throw new FileNotFoundException("配置文件名字不对");
        }
        // 打开文件
    }
    public void readConfig(){
    }
}

⚠调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

回到刚刚那个clone报红的错误

为什么加了这个之后就不报错了呢？

如果一个方法内部存在一个编译时异常(受查异常)，此时这个编译时异常一定要进行处理

目前我们的处理方式是在方法定义的时候，通过throws关键字声明异常，把这个异常交给JVM处理

还有下面这个例子

    public static void func() throws CloneNotSupportedException{
        int a = 10;
        if(a == 10){
            throw new CloneNotSupportedException("hhhh!");
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException{
        func();
    }

这段代码实际上我们是没有处理这个异常的，而是交给了JVM

那我们不想交给JVM怎么办？用try-catch

try-ctach

把光标放在异常方法上面，alt+enter

程序直接帮你自己处理

交给JVM处理和我们人工处理的区别

交给JVM处理，程序会异常终止，无法打印after

我们自己处理，没有红字报异常，还能打印after

catch里面的参数是我要捕获的异常，只有捕获到了才会执行catch当中的内容

还可以连续用catch捕获多个异常

如果抛出异常类型与 catch 时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序 ---- 异常是按照类型来捕获的

（PS：可以这样书写多个异常）

那我怎么知道这个算术异常发生在第几行，其实只用加一句

e.printStackTrace();

最好不要直接用父类接收所有的异常子类

因为捕获的异常不精准

但是Exception的捕获可以殿后，可以防止漏了哪些异常没有捕获到

关于异常的处理方式

异常的种类有很多 , 我们要根据不同的业务场景来决定 .

对于比较严重的问题 ( 例如和算钱相关的场景 ), 应该让程序直接崩溃 , 防止造成更严重的后果

对于不太严重的问题 ( 大多数场景 ), 可以记录错误日志 , 并通过监控报警程序及时通知程序猿

对于可能会恢复的问题 ( 和网络相关的场景 ), 可以尝试进行重试 .

在我们当前的代码中采取的是经过简化的第二种方式 . 我们记录的错误日志是出现异常的方法调用信息 , 能很

快速的让我们找到出现异常的位置 . 以后在实际工作中我们会采取更完备的方式来记录异常信息 .

finally

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

在语法中，finally下面的句子一定是会被执行的

    public static int func(){
        try{
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e){
            System.out.println("捕获到空指针异常");
        }finally{
            System.out.println("执行了finally");
        }
        return 10;
    }

    public static void main(String[] args) {
        System.out.println(func());
    }

注意：一般不建议在finally中写return

自定义异常

我们尝试写一个简单的登录后端

public class LogIn {
    private String userName = "admin";
    private String password = "123456";
    public static void loginInfo(String userName, String password) {
        if (!userName.equals(userName)) {
            //用户名有问题
            
        }
        if (!password.equals(password)) {
            //密码有问题
        }
        System.out.println("登陆成功");
    }
    public static void main(String[] args) {
        loginInfo("admin", "123456");
    }
}

如果用户名有问题怎么办？密码有问题怎么办？

我们考虑自己写异常，在有问题的地方抛出

我们看看Java自己的异常怎么写的

不难发现，写一个自定义异常需要继承一个异常，一般是extends Exception（默认受查异常）或者extends RuntimeException（默认非受查异常）

下面是自己写的针对用户名和密码问题的异常，继承Exception，一旦发现问题就抛出一条信息出来

class UserNameException extends Exception {
    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends Exception {
    public PasswordException(String message) {
        super(message);
    }
}

前面的代码可以改成

public class LogIn {
    private String userName = "admin";
    private String password = "123456";
    public static void loginInfo(String userName, String password) throws UserNameException, PasswordException{
        if (!userName.equals(userName)) {
            //用户名有问题
            throw new UserNameException("用户名有问题！");
        }
        if (!password.equals(password)) {
            //密码有问题
            throw new PasswordException("密码有问题！");
        }
        System.out.println("登陆成功");
    }
    public static void main(String[] args) {
        try{
            loginInfo("admin", "123456");
        }catch(UserNameException e){
            
            
        }catch(PasswordException e){
            
        } finally{
            
        }
    }
}

当然如果继承的是RuntimeException，那main方法里面都不用加try-catch了，直接调用loginInfo

而且loginInfo后面不用加throws ...了