异常的简单知识点，快速了解

什么是java中的异常

类比我们在生活中会生病，我们的身体出现了异常，Java中代码的运行也会出现错误，就叫做异常。有很多不同类型的异常，我们可以根据不同的异常去检查错误。

常见的异常

算数异常： System.out.println(10/0);

//输出结果为

Exception in thread "main" java.lang.ArithmeticException: / by zero

数组越界异常：

int[] array = {1,2,3}; System.out.println(array[4]);

//输出结果为：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException

 还有很多很多不同的异常。我们可以简单分类：

异常的结构

主要可以分为两大类：分别是Exception和Error，两者又分出很多不同的异常，

二者有什么不同呢？简单理解为：

Error是一种很严重的疾病，出现错误无法运行了，结束了。我们常称它为错误。

典型例子：StackOverflowError

Exception是小感冒之类的，我们使用代码处理后，就可以正常运行了。我们常常说的就是这个异常。

异常的分类

根据在程序什么时候发现错误，分为编译时异常（通常也可以称为：受检查异常）和运行时异常（通常也可以称为：非受检查异常）。

异常中的五个关键字，我们都需要了解并学会使用他：throw、try、catch、final、throws

throw

是用来抛出异常，我们设置一个条件，满足此条件我们就抛出异常

抛出的异常必须是excption或者它的子类，也可以同时抛出多个异常，异常之间用逗号隔开。

public static void func(int[] array, int pos) {
    if(pos >= 3) {
        throw new ArrayIndexOutOfBoundsException("出现异常！");
    }
}
public static void main(String[] args) throws CloneNotSupportedException {
    int[] array = new int[3];
    func(array,10);
}
运行结果为：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 出现异常！

此时程序终止。

throws 

根据在程序什么时候发现错误，分为编译时异常（通常也可以称为：受检查异常）和运行时异常（通常也可以称为：非受检查异常）

编译时异常  我们需要声明这个异常来解决它，至少在编译时期不报错，需要使用 throws 关键字声明这个异常。如下列：

private String name;
private int age;
@Override
public Test clone(){
    return (Test) super.clone();
}
public static void main(String[] args){
    Test test = new Test();
    Test test2 = test.clone();
}

编译也未通过：java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出

@Override
public Test clone() throws CloneNotSupportedException {
    return (Test) super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException 

在构造函数和主函数后面加上 throws CloneNotSupportedException  就可以解决此问题（这个问题是指编译时出错的问题）

所以在运行的时候仍然会报错，并且终止此程序。

下面是我们即使出现异常了依然会完成未完成的代码。

try 和 catch

我们将代码放在try里面，这个代码中如果出现异常的错误了会被catch捕捉到，然后就会执行catch里面的代码，然后执行接下来的代码。

public static void main(String[] args){
    try {
        int[] array = new int[3];  //这里面是我们可能会出现异常的代码。
         System.out.println(array[3]);
    }catch (要捕捉得异常（ArrayIndexOutOfBoundsException） e) {
        //我们将会在这里捕捉到异常（如果出现的话）
        e.printStackTrace();        //这里面会打印出来这个捕捉到的异常，红字，更加明显。
        System.out.println("代码出现错误了！！");  //这行代码可以打印，也就是我们想怎么                    处理这个异常可以在这里面执行。
    }catch (要捕捉得异常（ArrayIndexOutOfBoundsException） e) {
        //我们可以使用多个catch来捕捉异常。
    }
    System.out.println("代码运行了！！");  //在捕捉到异常出来后，接下来的代码照样会执行。
}

try中可能抛出异常，也可能不抛出。 

如果try中的异常抛出了，但是我们的catch中捕捉的异常不是抛出的异常，相当于没有捕获异常，catch中的代码无法运行，程序终止。

如果我们对一些异常的操作都一样，那么我们可以这样来catch异常

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

finally 

我们可以在catch的最后来使用它，无论什么情况下他都可以执行，使用return 0

finally里面的代码都会执行。

代码示例：
try {
    int[] array = new int[3];  //这里面是我们可能会出现异常的代码。
    System.out.println(array[4]);
}catch(ArrayIndexOutOfBoundsException e) {
    System.out.println("===========");
}finally {
    System.out.println("finall的执行！");
}

运行结果

===========
finall的执行！

finally常常用来完成一些最后结束的清理工作。

小结

异常的处理流程：

1、先执行try的代码

2、throw捕捉异常，如果和try中的异常相同，那么执行throw中的代码，反之首先完成finally中的代码，然后报错代码终止。

自定义异常

 Java中内置的类很多了，但是无法完全适应我们遇到的全部异常，因此我们需要自定义异常来完善我们的代码。

格式为  ：

class + 自定义异常的类名 + extends + Exception 或者 RunTimeException

如果继承了Exception，这个异常就是受查异常。

继承了RunTimeException，这个异常就是非受查异常。

简单来说就是创建一个类然后继承父类异常。

在这个类里面我们需要完成两个构造函数（有参）和（无参），我们记住就行，固定这个格式，写起来也很简单：

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

之后我们就可以用这个异常了，和Java内置的异常用法是一样的。

 结尾

如有错误，希望指正。

一定要坚持写博客呀！