异常—JAVA

异常的概念

首先在学习之前我们要先知道什么是异常，异常简单来说就是不对的地方我们说一个人某个部位疼痛不舒服，其实意思就是这个地方发生了异常了。那么人生病有大有小对应的异常也是如此，在没有学习异常之前我们对异常的处理都是交给jvm来处理的，而jvm在处理异常的时候统一的将各种异常都判定为终止运行了这样肯定是太过严苛的，就比如说我们人会生病难道我们就得了一个小感冒就直接晕倒在床上，终止生活了吗？肯定是不行的，因此我们需要自己处理这些异常并且判定异常的等级对于不是特别严重的异常我们就记录一下不能让程序直接崩溃。

异常的体系结构

说完了异常的概念我们来说一下异常的体系结构，对于面向对象的高级语言来说每一个面向对象的高级语言都是有自己的异常的体系结构的，包括c++啊python以及我们现在学习的JAVA，那么我们在未来工作中也是如此一些公司也会自己定义自己的异常体系结构。那么JAVA中的异常体系结构是什么样子的呢？如下图

从这张图片我们可以看到JAVA的异常体系中最上面是一个Throwable这样的一个超类，之后往下的Error和Exception都是继承这个超类的，之后向下分支进行细分。

1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
2. Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：
   StackOverflowError和OutOfMemoryError，一旦发生回力乏术。
3. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说
   的异常就是Exception。

异常的分类

根据程序的编译和运行异常也分为编译异常和运行异常，编译异常一般比较严重程序根本跑不起来但是在实际开发中其实最头疼的是运行时异常那么我们来对这两种异常进行一个举例

class Demo{
    public Demo clone(){
        return (Demo)super.clone();
    }
}

以上代码在执行时就会抛出异常报错信息如下

而这个就是编译异常。
注意!!!

编译时出现的语法异常并不能称之为异常，这确切来说应该叫编译时出错，不能称之为异常。

运行时异常

运行时异常和编译时异常最大的不同就是，是否产生了class文件，编译时异常是没有产生class文件的而运行时异常时已经产生了class文件。是在执行已经产生了的class文件时发生了异常。最为简单的就是除0异常。

异常的处理

关于异常的处理我们主要就是通过以下方式进行解决

防御式编程

错误在代码中是客观存在的因此重要的是当出现错误的时候我们应该如何让程序员知道这个错误，就像恋爱中犯错肯定是会有的，问题是你应当如何知道或者弥补自己犯下的错误这里主要有两种方式。

---

1. 事前防御型
2. 事后补偿型

什么是事前防御型呢？
例如以下代码

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

可以看到这里面用了大量的if else
但是这样也有一个缺点那就是正常流程和错误处理流程代码混在一起, 代码整体显的比较混乱。简称屎山
那么在实际开发中我们的核心一般都是什么呢？一般都是事后认错型列如以下代码

public class Main {
    public static void main(String[] args) {
       //String str=new String("abcd")
        Scanner scan=new Scanner(System.in);
        int x=scan.nextInt();
        int y=scan.nextInt();
        try{
            System.out.println(x/y);
        }
        catch(RuntimeException e){
            System.out.println("除法异常");
        }
    }
}

上面我们输入10和0对应得处理如下

优势：正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码
异常处理的核心思想就是 EAFP。
在Java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

异常的抛出

在处理异常的时候我们需要对发生的异常进行抛出来告诉调用自己的方法自己发生了异常并让其进行处理
在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

throw ***Exception("产生异常的原因");

那么代码如下

import java.util.Scanner;

// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
class Math{
    public int div(int x,int y){
       if(y==0)
       {
           throw new RuntimeException("初灵错误");
       }
       return x/y;
    }
}
public class Main {
    public static void main(String[] args) {
       //String str=new String("abcd")
        Scanner scan=new Scanner(System.in);
        int x=scan.nextInt();
        int y=scan.nextInt();
        try{
            Math m=new Math();
            m.div(x,y);
        }
        catch(RuntimeException e){
            System.out.println("除法异常");
        }
    }
}

注意!!!

• throw必须写在方法的内部
• 抛出的对象必须是Exception或者Exception的子类.
• 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
• 如果抛出的是编译时异常则用户必须处理否则就会编译时不通过
• 异常一旦抛出，其后的代码就不会执行除非被finally修饰

异常的捕获

异常的捕获也就是异常的具体处理方式主要有两种一种是try-catch捕获还有一种时throws声明。

异常声明throws

处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛
给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。

语法格式：
修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}

需求加载配置文件

public class Config {
File file;
/*
FileNotFoundException : 编译时异常，表明文件不存在
此处不处理，也没有能力处理，应该将错误信息报告给调用者，让调用者检查文件名字是否给错误了
*/
public void OpenConfig(String filename) throws FileNotFoundException{
if(filename.equals("config.ini")){
throw new FileNotFoundException("配置文件名字不对");
}
// 打开文件
public void readConfig(){
}
}
}

注意

1. throws必须跟在方法的参数列表之后
2. 声明的异常必须是 Exception 或者 Exception 的子类
3. 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型
具有父子关系，直接声明父类即可。
4. 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

try—catch捕获并处理

throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行
处理，就需要try-catch。具体用法其实就是上面举出的那个列子

public class Main {
    public static void main(String[] args) {
       //String str=new String("abcd")
        Scanner scan=new Scanner(System.in);
        int x=scan.nextInt();
        int y=scan.nextInt();
        try{
            System.out.println(x/y);
        }
        catch(RuntimeException e){
            System.out.println("除法异常");
        }
    }
}

关于异常的处理方式
异常的种类有很多, 我们要根据不同的业务场景来决定.
对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后果
对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿
对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试.
在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很
快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息.

注意

1. try中抛出异常的位置之后的代码将不会被执行。
2. catch捕获异常必须要与抛出的异常类型相符合不然依旧不会处理这个异常相当于没有捕获到
3. try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获
4. 如果多个异常的处理格式完全相同也可以下面这样写

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
...
}

5. 如果异常之间具有父子关系（结合上面那个异常体系的图Exception时所有异常类的父类），一定是子类异常在前catch，父类异常在后catch，否则语法错误
6. 可以通过一个catch捕获所有的异常，即多个异常，一次捕获(不推荐)

finally

被finally代码修饰的代码时必须执行的代码他的优先级非常的高具体到哪种程度请看下面的代码

class Math{
    public int div(int x,int y){
       try{
           return x;
       }finally {
          return y;
       }
    }
}

如果输入的时10和0那么这个程序会返回多少呢？答案是0因此通过这个代码大家应该就能知道finally的强度了

异常的处理流程

关于 “调用栈”
方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在 JVM 中有一块内存空间称为
“虚拟机栈” 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的
方式查看出现异常代码的调用栈.
如果说一直沿着被调用的顺序一直向上传递直到最后都没有处理异常的话最终异常会交给JVM处理

异常处理流畅总结
程序先执行 try 中的代码
如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
如果找到匹配的异常类型, 就会执行 catch 中的代码
如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
如果上层调用者也没有处理的了异常, 就继续向上传递.
一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

自定义异常类

Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我
们实际情况的异常结构.
例如, 我们实现一个用户登陆功能

class login{
    private int password=123456;
    private String username="admin";
    public void log(int password_,String username_){
        if(password_!=password){

        }
        if(username_.equals(username)){
            
        }
        System.out.println("登录成功");
    }
    
}

此时我们在处理用户名密码错误的时候可能就需要抛出两种异常. 我们可以基于已有的异常类进行扩展(继承), 创建
和我们业务相关的异常类.
具体方式
首先先创建一个自己的异常类，之后这个异常类继承Exception或者RuntimeException实现一个带有String的构造方法参数的含义就是出现异常的原因。
经过改良之后我们的代码就可以像下面这样写了

import java.util.Scanner;
class passwordException extends Exception {
    public passwordException(){
        super();
    }
    public passwordException(String be){
        super(be);
    }
}
 class usernameExprction extends Exception {
    public usernameExprction(){
        super();
    }
    public usernameExprction(String be){
        super(be);
    }
}

// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
class login{
    private int password=123456;
    private String username="admin";
    public void log(int password_,String username_) throws usernameExprction,passwordException{
        if(password_!=password){
            throw new passwordException("密码错误");
        }
        if(username_.equals(username)){
            throw new usernameExprction("用户名错误");
        }
        System.out.println("登录成功");
    }

}
public class Main {
    public static void main(String[] args) {
       //String str=new String("abcd")
       try{
            login l=new login();
            l.log(123,"ad");
       }catch(passwordException e){
            e.printStackTrace();
       }catch (usernameExprction e){
            e.printStackTrace();
       }
    }
}