前言：

1.异常的概念

2.异常的分类

2.1编译时异常

2.2运行时异常

3.异常的处理

3.1如何抛出异常

3.2异常的捕获

3.2.1异常的声明

3.2.2try-catch捕获并处理

3.3异常的处理流程

4.自定义异常类

结束语：

前言：

相信在大家学习Java和敲代码的过程中会时不时的出现一些问题，有些是编译器自己报出来的错误，有些是我们自己手动排除的错误，那么在编译器报出一些错误的时候就会有助于我们更快的找到代码的错误，可以更好更快的解决这个问题，那么编译器出现的这种情况就是异常，接下来就和小编从下面的几个方面来了解一下什么是异常，最后我们如果要自己编写一个异常又该如如何去写呢？话不多说，上干货！！！

1.异常的概念

在生活中程序猿是一群办事严谨、追求高科技的技术性人才，所以在日常的开发中会绞尽脑汁的将代码写的尽善尽美，但是在程序运行的过程中，难免会出现一些奇奇怪怪的问题，有时候通过代码很难去控制，比如数据格式不对、网络不通畅、内存报警等。在Java中将程序执行过程中发生的不正常行为称为异常。

比如我们之前遇到过的：

1.算数异常

2.数组越界异常

3.空指针异常

2.异常的分类

首先我们先来看一下异常的体系结构：

从上图中我们可以看到：

Throwable：是异常体系的顶层类，其派生出两个子类：Error和Exception。
Error：指的是java虚拟机无法解决的问题，比如：Java的内部错误，资源耗尽等，一旦发生就需要程序员来解决。
Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。

那么接下来我们就看一下异常的两大类：编译时异常和运行时异常。

2.1编译时异常

在程序编译期间发生的异常，称之为编译时异常，也称之为受检查异常。

下面出现的就是编译时异常

在编译时异常时我们需要声明一下异常，这个我们后面会讲到的。

2.2运行时异常

在程序执行期间发生的异常，称之为运行时异常，也称之为非受检查异常。如下所所示：

RunTimeException以及其子类对应的异常，都称之为运行时异常。要注意的是在编译的时候出现的语法性错误不叫异常。

3.异常的处理

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

那么下面我们就分别看一下这几个关键字。

3.1如何抛出异常

在编写程序时，如果程序出现错误，此时就需要将错误的信息告知给调用者，那么在Java中我们可以通过throw关键字来抛出一个异常对象，将错误的信息告知给调用者。

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

注意：

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

代码如下所示：

public class Test2 {
    public static void getArray(int[] array) {
        if(null == array) {
            throw new NullPointerException("空指针异常！！！");
        }
        for (int i = 0; i < array.length; i++) {
            if (i > array.length) {
                throw new ArrayIndexOutOfBoundsException("数组越界异常！！！");
            }
            System.out.print(array[i] + " ");
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        getArray(array);
    }
}

正常执行代码结果下所示：

如果中途出现异常的情况下：

代码如下所示：

public class Test2 {
    public static void getArray(int[] array) {
        if(null == array) {
            throw new NullPointerException("空指针异常！！！");
        }
        for (int i = 0; i < array.length; i++) {
            if (i > array.length) {
                throw new ArrayIndexOutOfBoundsException("数组越界异常！！！");
            }
            System.out.print(array[i] + " ");
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        int[] array2 = null;
        getArray(array2);
        getArray(array);
    }
}

异常情况下结果如下所示：

代码不会再继续往下运行！！！

3.2异常的捕获

那么出现异常后我们应该如何处理呢？此时我们就需要异常的捕获了，处理方式主要有两种：异常的声明和try-catch捕获异常。

3.2.1异常的声明

语法格式：

修饰符返回值类型方法名（参数列表）throws 异常类型1，异常类型2……{

}

代码如下所示：

public class Test3 {
    public static int Div(int x, int y) throws ArithmeticException{
        return x / y;
    }
    public static void main(String[] args) throws ArithmeticException{
        System.out.println(Div(2, 3));
    }
}

注意：

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

3.2.2try-catch捕获并处理

在上述的throws其实并未对异常进行处理而只是将异常报告给抛出异常方法的调用者，由调用者处理，如果真正要对异常进行处理，就需要try-catch。

语法格式：

try {
    //将可能出现异常的代码放到这里面
}catch (要捕获的异常的类型 e) {
    //如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常的类型一致时，或者是try中抛出异常的基类时，就会被捕获到。
    //对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后续代码。
}finally {
    //此处的代码一定会被执行到
}
//后续的代码
//当异常被捕获到时，异常就被处理了，这里的代码一定会被执行
//如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行。

示例代码如下所示：

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            System.out.println(a / b);
            int[] array = {1,2,3,4,5};
            System.out.println(array[5]);
        }catch (ArithmeticException e) {
            e.printStackTrace();//打印红字
            System.out.println("捕捉到了ArithmeticException异常！！！");
            //写进行处理的逻辑
        }catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
            //可以通过 | 来进行多个异常的捕获
            e.printStackTrace();
            System.out.println("捕捉到了NullPointerException| ArrayIndexOutOfBoundsException异常！！！");
            //写进行处理的逻辑
        }finally {
            System.out.println("finally一般用于资源的释放！！！");
        }
    }
}

结果如下所示：

注意：

try块内抛出异常位置之后的代码块将不会被执行。
如果抛出异常类型与catch捕获的类型不匹配，即异常不会被成功捕获成功，也就不会被处理，继续往外抛异常，直到JVM收到中断程序。
try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获，即多个异常，多次捕获。
如果多个异常的处理情况是完全相同的，那么我们就可以通过“ | ”来进行分隔。
如果异常之间存在父子关系，那么一定是子类异常的catch在父类异常的catch之前，否则就会出现语法错误。
可以通过一个catch（Exception）捕获所有异常，即多个异常，一次捕获。但是不推荐。

3.3异常的处理流程

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

4.自定义异常类

Java中虽然已经内置了丰富的异常类，但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的一些异常类。

具体方式如下所示：

自定义异常类，然后继承Exception或者是RunTimeException。
实现一个带有String类型参数的构造方法，参数含义：出现异常的原因。
继承自Exception的异常默认是受查异常。
继承自RunTimeException的异常默认是非受查异常。

下面我们通过一个登录界面来说明一下自定义异常，以及在将前面的知识串起来。

登录界面：

代码如下所示：

public class Test {
    public static void main(String[] args) {
        Login login = new Login("admin","1234");
        try {
            login.button("admin","123");
        }catch (UserNameException e) {
            e.printStackTrace();
            System.out.println("用户名异常！");
        }catch (PasswordException e) {
            e.printStackTrace();
            System.out.println("密码错误！");
        }finally {

        }
    }
}

public class Login {
    private String name = "admin";
    private String password = "1234";

    public Login(String name, String password) {
        this.name = name;
        this.password = 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 button (String name, String password) throws UserNameException , PasswordException{
        if (!this.name.equals(name)) {
            throw new UserNameException("你的用户名错了！！！");
        }
        if (!this.password.equals(password)) {
            throw new PasswordException("你的密码错了！！！");
        }
    }
}

public class PasswordException extends RuntimeException{
    public PasswordException() {
        super();
    }
    public PasswordException(String s) {
        super();

    }
}

public class UserNameException extends RuntimeException{
    public UserNameException() {
        super();
    }
    public UserNameException(String name) {
        super(name);
    }
}

结果如下所示：