异常机制

什么是异常？异常的分类？

Java异常是java提供的用于处理程序中错误的一种机制。

所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0错误，数组下标越界，所要读取的文件不存在）。设计良好地程序应该在程序异常发生时提供处理这些错误的方法，使得程序不会因为异常的发送而阻断或产生不可预见的结果。

Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息，并将被提交给java运行时系统，这个过程称为抛出异常。

当java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交其处理，这一过程称为捕获异常。

异常的分类：

Error：称为错误，由java虚拟机生成并抛出，包括动态链接失败，虚拟机错误等，程序对其不做处理。

Exception：所有异常类的父类，其子类对应了各种各样的可能出现的异常事件，一般需要用户显示的声明或捕获。

Runtime Exception:一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）。

异常处理的两种方式

​ 捕获异常： try...catch...finally

​ 抛出异常：throw throws

​ 其实异常部分主要讲的就是五个关键字：try、catch、finally、throw、throws

try语句

​ try{...}语句制定了一段代码，这段代码就是一次捕获并处理异常的范围。在执行过程中，这段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。如果没有异常发生，所有的catch代码段都被略过不执行。try里面放一些有可能出现异常的代码，那么无谓的代码就不要往里面放，会影响性能。

public class MyTest {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        int[] arr={2,3};
        arr=null;
        try {
            //try 里面放一些有可能会出现异常的代码，那么无谓的代码就不要往里面放
            System.out.println(arr.length);
            System.out.println(a / b);
            System.out.println(arr[3]);
            System.out.println("====================");
        //catch 可以并列写多个，捕获不同的异常
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组角标越界异常");
        }catch (ArithmeticException e){
            System.out.println("除数为0的异常");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }catch (Exception e){
            System.out.println("其他异常");
        }

        //注意：你能明确的异常类型，尽量名确，不要一股脑的全用异常的父类捕获了
        //如果你捕获的异常，是平级关系，谁前谁后无所谓，如果异常之间有继承关系，父类异常放在最后

        System.out.println("下面的代码");
        //ctrl+H 可以看一个类的继承关系
}

catch语句

​ 在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。在catch中声明的异常对象（catch(XxxException e)）封装了异常事件发生的信息，在catch语句块中可以使用这个对象的一些方法获取这些信息。

可以并列写多个，捕获不同的异常。

注意：你能明确的异常类型，尽量明确。尽量不要用异常的父类Exception捕获

如果你捕获的异常，是平级关系，谁前谁后无所谓，如果异常之间有继承关系，父类放在最后

finally语句

​ finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够对程序的状态做统一的管理。无论try所指定的程序块中是否抛出异常，finally所指定的代码都要执行。通常在finally语句中可以进行资源的清除工作。finaly里面的代码，不管try里面有没有遇到异常，都会执行

public static void main(String[] args) {
    Scanner scanner=null;
    try {
        scanner= new Scanner(System.in);
        System.out.println("请输入第一个数");
        int a = scanner.nextInt();
        System.out.println("请输入第二个数");
        int b = scanner.nextInt();
        System.out.println(a / b);
         }catch (ArithmeticException e){
        //遇到以你捕获的该类的异常，就执行
        System.out.println("除数为0");
    } finally {
        //我们一般在finally里面喜欢做一些善后收尾工作，比如释放资源
        System.out.println("finally里面的代码，不管try 里面有没有遇到异常，都会 执行");
        if (scanner != null) {       //非空判断
            scanner.close(); //释放资源
        }
    }
}

​ throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。

​ throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通常throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指定要抛出的异常；如果要捕获throw抛出的异常，则必须使用try{}catch{}语句。

运行期异常：

运行期的异常处理：IDEA可以按”ctrl+alt+T“把你括住的一段代码，进行异常处理

 public static void main(String[] args) {
        //Throwable 问题
        // Error 错误，无法解决，内存溢出
        //Exception 异常，属于一般性问题，我们可以解决，我们在写程序过程中需要处理的就是异常
        //运行期异常：发生在程序运行过程当中，你可以解决，也可以不解决
        //编译期异常：发生在编译期间，你必须解决，不解决程序无法运行
        int a=10;
        int b=0;
        //ArithmeticException
        //当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。
        System.out.println(a/b);
        //运行期异常的默认处理方式：是抛给了JVM去处理，那么JVM的默认处理方式，是打印异常的堆栈信息，然后退出虚拟机。
        //那如果说，你决定JVM默认处理异常的方式，不够友好，那么你自己可以捕获异常自己处理
        //那么我自己如何处处理？
        System.out.println("下面的代码");    
    }
 

如下处理方法：

public static void main(String[] args) {
        //我们自己处理运行期异常，使用关键字try{}catch()
        int a=1;
        int b=0;
        try {
            //try 里面放的是，有可能会出现异常的代码，一旦出现异常，就会执行catch里面的代码
            //当然try里面没有遇到异常，那么catch里面的代码，就不执行
            System.out.println(a / 1);
        }catch (ArithmeticException e){
            //处理异常的方式
            System.out.println("除数为0了");
        }
        System.out.println("下面的代码");  
    }

编译期异常

编译期异常的处理：用IDEA按住“alt+enter”使用万能纠错键，选择抛出，或者捕获

编译期异常：非 RuntimeException及其子类，发生在编译期间，必须处理，不处理程序无法运行

编译期的处理方式：一种抛给调用者处理（throw），谁调用谁处理，简称甩锅，一般抛到了main方法的时候就不要甩了。

另一种就是自己捕获处理

父类和子类方法异常注意事项：

1.子类在重写父类方法时，方法内部有编译期异常，如如果父类方法，没有抛出该异常，那么子类就不能抛出

2.子类不能抛出父类没有抛出过的异常

3.父类有抛出异常，子类可以不抛出异常

4.子类抛出的异常不能比父类大，只能比父类小，或者跟父类一样

编译期异常和运行期异常的区别？

​ 编译时异常：程序正确，但因为外在的环境条件不满足引发。对商用软件系统，程序开发者必须考虑并处理这类异常。Java编译器强制要求处理这类异常，如果不捕获这类异常，程序将不能被编译。

​ 运行期异常：这意味着程序存在bug，如数组越界，0被除，传入参数不满足规则等，这类异常需要更改程序来避免，java编译器强制要求处理这类异常。

​ 错误：一般很少见，也很难通过程序解决。它可能源于程序的bug，但一般更可能源于环境问题，如内存耗尽。错误在程序中无须处理，而由运行环境处理。

Throwable 问题：

1. Error 错误，无法解决，内存溢出
2. Exception 异常，属于一般性问题，我们可以解决，我们在写程序过程中需要处理的就是异常
3. 运行期异常：发生在程序运行过程当中，你可以解决，也可以不解决
4. 编译期异常：发生在编译期间，你必须解决，不解决程序无法运行

final、finally与finalize的区别

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成final类型。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提高垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

异常的注意事项及如何使用异常处理？

1. 子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。

2. 如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常。

3. 如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try...catch，不能throws

文件名称过滤器FilenameFilter的作用

FilenameFilter是文件名过滤器，用来过滤不符合规则的文件名，并返回合格的文件。

最常见到的5个RuntimeException异常

NullPointerException - 空指针引用异常

ClassCastException - 类型强制转换异常

IllegalArgumentException - 传递非法参数异常

ArithmeticException - 算术运算异常

IndexOutOfBoundsException - 下标越界异常

NumberFormatException - 数字格式异常

自定义异常

当Java提供的这些异常类，并不能完全描述，我在开发中描述的异常，那么就需要我们自定义异常