异常(Java)

1. 异常的概念

2. 异常的分类

3. 异常的处理

4. 异常的抛出

5. 异常的捕获

5.1 异常声明throws

5.2 try-catch捕获并处理

5.3 finally

6. 异常的处理流程

7. 自定义异常类

1. 异常的概念

异常就是在程序执行过程中发生的不正常的行为.异常中断了正在执行程序的正常指令流。

异常其实就是类.异常是可以继承的。

算数异常、空指针异常、下标越界异常

throwable:是异常体系的顶层类，派生出两个子类：Error和Exception
Error:Jav虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等
Exception:异常产生后程序员可以通过代码进行处理，使程序继续执行

2. 异常的分类

异常包括：运行时异常（不受查异常）和编译时异常（受查异常）

注意：

编译时出现的语法性错误，不能称为异常，这是“编译期”出错，而运行时指的是程序已经编译通过得到class文件了，再由JVM执行过程中出现的错误。

3. 异常的处理

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

缺陷：正常流程和错误处理流程代码混在一起，代码整体显得较为混乱

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

优势：正常流程和错误流程是分离开的，代码更清晰，更易理解。

异常处理的核心思想就是EAFP

在java中，异常处理的5个关键字：throw,try,catch,finally,throws

4. 异常的抛出

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

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

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

public class Test {
    public static void testException(int a) {
        if (a == 0) {
            throw new ArithmeticException("a==0");
        }
    }

    public static void main(String[] args) {
        testException(0);
    }
}

注意：

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

5. 异常的捕获

异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws以及try-catch捕获处理。

5.1 异常声明throws

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

    public static void testException(int a) throws NullPointerException {
        if (a == 0) {
            throw new ArithmeticException("a==0");
        }
    }

注意：

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

5.2 try-catch捕获并处理

throws对异常没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要try-catch.

public class Test {
    public static void function(int a) throws CloneNotSupportedException {
        if (a == 10) {
            throw new CloneNotSupportedException();
        }
    }

    public static void main(String[] args) {
        try {
            function(10);
            System.out.println("haha");
        } catch (CloneNotSupportedException e) {
            System.out.println("捕获异常，处理异常");//
        }
        System.out.println("程序继续执行");//
    }
}

public class Test {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        try {
            //System.out.println(array[4]);
            array=null;
            System.out.println(array.length);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("处理ArrayIndexOutOfBoundsException异常");//
            e.printStackTrace();
            //java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 3
            //	at Test.main(Test.java:5)
        } catch (NullPointerException e) {
            System.out.println("处理NullPointerException异常");
            e.printStackTrace();
            //java.lang.NullPointerException: Cannot read the array length because "array" is null
            //	at Test.main(Test.java:7)
        }
        System.out.println("after");//
    }
}

不会同时抛出多个异常类型

不能任何异常都用Exception解决，Exception是所有异常的父类，从上到下进行捕捉

try块内抛出异常位置之后的代码将不会被执行
如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序--异常是按照类型来捕获的
try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获--即多种异常，多次捕获
如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误
可以通过一个catch捕获所有的异常，即多个异常，一次捕获（不推荐）

由于Exception类是所有异常类的父类，因此可以用这个类型捕获所有异常

5.3 finally

不管是否发生异常，finally都会被执行，一般用于资源的释放。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题。

finally执行的时机是在方法返回之前（try或者catch中如果有return会在这个return之前执行finally）。但是如果finally中也存在return语句，就会执行finally中的return，从而不会执行到try中原有的return.

一般不建议在finally中写return（被编译器当作一个警告）

throw和throws的区别：

throw和throws的区别-CSDN博客

6. 异常的处理流程

public class Test {
    public static void test1() {
        int[] array = {1, 2, 3, 4};
        System.out.println(array[10]);
    }

    public static void main(String[] args) {
        try {
            test1();
        } catch (ArrayIndexOutOfBoundsException e) {

        }
        System.out.println("异常已处理");//
    }
}

如果向上一直传递都没有合适的方法处理异常，最终就会交给JVM处理，程序就会异常终止（和我们最开始未使用try catch时是一样的）

异常处理流程总结：

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

7. 自定义异常类

Test类:

package demo;

class login {
    private String name;
    private String password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void logIn(String name, String password) throws PassWordException, NameException {
        if (!this.name.equals(name)) {
            throw new NameException("用户名错误异常");
        } else if (!this.password.equals(password)) {
            throw new PassWordException("密码错误异常");
        } else {
            System.out.println("登录成功！");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        login login = new login();
        login.setName("admin");
        login.setPassword("123456");
        try {
            login.logIn("admin", "12456");
        } catch (PassWordException e) {
            e.printStackTrace();
        } catch (NameException e) {
            e.printStackTrace();
        } finally {

        }
    }
}

PassWordException类：（自定义）

package demo;

public class PassWordException extends RuntimeException {//运行时异常

    public PassWordException() {
        super();
    }

    public PassWordException(String message) {
        super(message);
    }
}

NameException类：（自定义）

package demo;

public class NameException extends RuntimeException {
    public NameException() {
        super();
    }

    public NameException(String message) {
        super(message);
    }
}