JavaSE学习值之--认识异常

💕"有效知识的前提是承认知识边界，承认我们对边界那边的一切无可奉告。"💕

作者：Mylvzi

文章主要内容：JavaSE学习值之--认识异常

一.什么是异常？

异常就是程序在运行的时候产生的不正常的行为 小细节没注意到，发生了小的错误，比如：

1.算数异常

        System.out.println(10/0);

2.空指针异常 null.length

        int[] arr = null;System.out.println(arr.length);

3.数组越界异常

        int[] arr = new int[3];System.out.println(arr[5]);

可见Java中java中不同类型的异常，都有与其对应的类来进行描述，实际上Java中的异常是一个大的体系

二.异常的体系：

异常它是由编译器识别并给出的，证明其存在于编译器所自带的库文件中，应该是一个类

1. Throwable：

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

2. Error：

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

3. Exception：

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

三.异常的分类：

主要是分为两大类

运行时异常（不受查异常）
RuntimeException()
编译时异常（受查异常）

1. RunTimeException 包括他的所有子类

在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception)

注意：

在编写代码过程中出现的语法错误不是运行时异常，比如把main写成了mian,编译器在编译的时候就会报错，这叫错"编译期错误"，而运行时异常的产生是所写代码已经经过编译生成.class文件了，再交由JVM运行时产生的错误

补充：RuntimeException的子类

2.编译时异常

在编译的时候就会发生的异常，又称作受查异常（Checked Exception）

比如之前实现的Cloneable接口

class Stu implements Cloneable {String name;int age;public Stu(String name, int age) {this.name = name;this.age = age;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic String toString() {return "Stu{" +"name='" + name + '\'' +", age=" + age +'}';}
}
public class Test1 {public static void main(String[] args){Stu stu = new Stu("lvzi",18);Stu stu2 =(Stu) stu.clone();System.out.println(stu2);
}

之前提到，必须在main方法的签名中声明抛出异常,否则会出现异常

这种在编译阶段就报错的异常叫做编译时异常，又叫做受查异常（Checked Exception）

四.异常的处理

1.防御式编程

错误的代码总是存在且不可避免地，我们要做的就是当程序出现异常的时候及时告诉程序员，来帮助他修改代码，主要有两种思路：

1.LBYL: Look Before You Leap. 在操作之前就做充分的检查. 即：事前防御型

即对每一个流程都充分想到其可能会发生的错误，及时处理

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

每进行一步就进行一次检查，但这种方式使正确代码和异常检查的代码混在一起，使得整个代码很混乱，不推荐

2.EAFP: It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理. 即：事后认错型

try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
}

EAFP的思维简单来说就是管他三七二十一，先执行再说，产生的异常事后处理即可

这种思维是的操作部分和异常处理部分分离，让程序员更加模块化的思考，更有利于代码的编写！！！

在Java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测

在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

throw new XXXException("异常产生的原因")

举例：

    public static int[] arr ={1,2,3};public static int getElem(int index) {if(index < 0 || index > arr.length) {throw new ArrayIndexOutOfBoundsException(index + "索引不正确，数组越界");}return arr[index];}public static void main(String[] args) {int[] arr ={1,2,3};System.out.println(getElem(0));// 正确  输出1System.out.println(getElem(10));// 异常System.out.println(getElem(1));// 不输出}

注意：

throw必须写在方法内部
抛出的异常必须是Exception或Exception的子类
如果抛出的异常是RuntimeException或其子类，不需要处理，直接交给JVM处理
如果抛出的异常是受查异常，必须通过throws进行处理，否则无法通过编译
.异常一旦抛出，其后的代码就不会执行

五.异常的捕获

异常的捕获就是异常处理的具体方式，包括两种方式

try,catch语句
throws声明

1.异常声明throws

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

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

比如上文的Cloneable接口的实现：

注意：

throws必须跟在方法的参数列表之后
声明的异常必须是 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抛出

2 try-catch捕获并处理

throws声明异常并没有处理异常，只是将异常交给调用者去处理，一直传递给JVM虚拟机；要想真正处理异常，就需要try-catch语句

注意：

1.try中存放可能出现异常的代码，也就是说不一定会抛出异常

2.catch（）存放异常的类型，{}内部存放处理的代码，处理完成后会继续执行后续代码；如果没有捕获到异常，则catch里的语句并不会被执行

3.finally中的语句一定会被执行，

4.打印异常有三种

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

6.如果异常之间存在父子关系，子类异常被捕获时在前，父类在后，如果顺序颠倒，子类异常的捕获就没有任何意义了

public static void main(String[] args) {
int[] arr = {1, 2, 3};
try {
System.out.println("before");
arr = null;
System.out.println(arr[100]);
System.out.println("after");
} catch (Exception e) { // Exception可以捕获到所有异常
e.printStackTrace();
}catch (NullPointerException e){ // 永远都捕获执行到
e.printStackTrace();
}
System.out.println("after try catch");
}

7.无论如何，finally中的代码一定会被执行

public static int[] arr ={1,2,3};public static int getElem(int index) {return arr[index];}public static void main(String[] args) {int[] arr ={1,2,3};try{System.out.print(getElem(100));// 异常}catch (Exception e) {e.printStackTrace();}finally {System.out.println("finally中的代码一定会被执行");}
}

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

思考：那我们该如何记录并处理异常呢？什么时间去处理异常呢？

在目前我们所写的代码中，常常采取记录错误日志的方式来记录异常，通过编译器的报错告诉程序员出错的地方

六.如何设计一个自定义类型的异常？

将你可能出现的异常设计为一个继承Exception或RunTimeException的类，添加一个带参数的构造方法（用于打印错误信息）,在调用时，一旦出错就抛出对应的异常即可

注意：继承Exception的类是受查异常，必须在调用的方法声明中添加throws该异常

继承RunTimeException的类是非受查异常，不需要添加声明

e.printStackTrace();打印异常信息

class UsernameException extends RuntimeException {public UsernameException(String message) {super(message);}
}class PasswdException extends RuntimeException {public PasswdException(String message) {super(message);}
}class Login {private String Username;private String Passwd;public static void logininfo(String Username,String Passwd) {if(!Username.equals("admin")) {throw new UsernameException("用户名错误");}else if(!Passwd.equals("123456")) {throw new PasswdException("密码错误");}}
}
public class Test1 {public static void main(String[] args) {try {Login.logininfo("admin2","123456");}catch (UsernameException ex) {ex.printStackTrace();}catch (PasswdException ex) {ex.printStackTrace();}}
}