java学习笔记（二十八）异常

异常：就是程序出现的不正常的情况。
异常分类：

    错误：这是非常严重的问题，一般我们处理不了。
    异常：
        编译时期异常  开始就必须要处理的，如果不处理，后面就走不了。
        运行时期异常  开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序。

体系结构：

Throwable：

    Error：
    Exception：
        非RuntimeException：
        RuntimeException：

异常演示：
除数不能为0

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("start");
        int a = 10;
        int b = 0;
        System.out.println(a/b);
        System.out.println("end");
    }

}
/*结果
 * start
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.edu_02.ExceptionDemo.main(ExceptionDemo.java:49)*/

针对异常，JVM默认的处理方案：
一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。并且，会自动从当前出问题的地方停止掉。

这种处理方案虽然可以，但是不够好。
哪里不好呢?
其实程序出问题，不应该直接停止，因为我们的程序可能是由多部分组成的，
其中一个部分出问题了，不应该影响其他部分的执行。
所以，我们应该想办法让其他的部分能够执行下去。

我们是如何处理异常，保证各个部分不影响的呢?
两种方案：
A:try…catch…finally
B:throws

try…catch…finally:

    try{
        可能出现异常的代码
    }catch(异常类名 变量名) {
        针对异常的代码处理
    }finally {
        释放资源的地方
    }

我们简化一下第一个：

  try{
        可能出现异常的代码
    }catch(异常类名 变量名) {
        针对异常的代码处理
    }

public class ExceptionDemo2 {
    public static void main(String[] args) {

        int a = 10;
        int b = 0;
        System.out.println("start");
        try{
            //这里书写的是可能出现异常的代码
        System.out.println(a/b);//-- 程序此时抛出异常
        //捕捉的异常
        }catch(ArithmeticException e){//--程序此时在这里抓取，try的代码块中出现的异常
            //出现异常之后，我们该怎么处理
            System.out.println("程序正在开小差");
        }
        System.out.println("end");
    }

}
/*结果
 * start
程序正在开小差
end*/

多个异常的处理(演示数组索引越界异常，除数为0异常)
A:针对每一个出现问题的地方写一个try…catch语句
B:针对多个异常，采用一个try，多个catch的情况。
try…catch…catch…

    遇到try里面的问题，就自动和catch里面进行匹配。
    一旦匹配就执行catch里面的内容，执行完毕后，接着执行后面的代码。

    注意：
        如果异常间有子父关系，父必须在最后。

public class ExceptionDemo3 {
    public static void main(String[] args) {
        //针对多个异常的解决方案
        int a = 10;
        int b = 0;
        int[] arr  ={10,20,30};
        System.out.println("start");
        try{
        System.out.println(a/b);
        System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException
        }catch(ArithmeticException e){
            System.out.println("除数为0");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("数组越界");
        }catch(Exception e) {
            //抓了一个父类的异常，一般是放你可能也不知道你这个程序会抛出什么异常
            System.out.println("程序出现问题了");
        }
        System.out.println("end");
    }

}
/*结果
 * start
除数为0
end*/

编译时期异常和运行时期异常的区别:
编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
运行时期异常：无需显示处理，也可以和编译时异常一样处理
Throwable中的方法：(演示除数为0异常)
printStackTrace():打印异常信息，程序从出问题的地方开始就会打印创建一个该异常对应的对象， 该对象直接调用打印方法打印出异常信息

try…catch和throws的区别
try…catch 是直接进行了处理。
而throws则是把异常处理的事情交给了调用者。

throws用在方法上，声明方法有异常，交给调用者处理。
但是呢，如果是编译时期异常，调用就必须处理。
如果是运行时期异常，调用者可以处理，也可以不处理。

public class ExceptionDemo6 {
    public static void main(String[] args) {
        // 在main方法中调用method()这个方法,此时method（）
        // 这个方法有异常抛出，调用者必须处理异常，程序才能运行吧
        // 在这里已经不能再去抛了，因为在这里已经到了程序运行的最底层了，
        // 我们已经不能再去抛了，如果再抛，就抛给了jvm虚拟机处理了，所以在这里只能抓
        try {
            method();
        } catch (FileNotFoundException e) {
            System.out.println("未找到文件");
        }
    }

    private static void method() throws FileNotFoundException {
        // 我们在method这个方法中，抛出一个编译器异常
        FileInputStream fis = new FileInputStream(new File("D//:a.jpg"));

    }

}

异常处理：
try…catch…finally

finally:一般用于释放资源。在数据库操作或者IO流比较常见。

特点：
被finally控制的语句体一定会执行

    特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

public class ExceptionDemo8 {
    public static void main(String[] args) {
        try{
        System.out.println(10/0);//抛出异常
        }catch(ArithmeticException e){
            System.out.println("除数为0");//抓住这个对应的异常之后，进行的一系列处理逻辑
            System.exit(0);
            //--jvm不就是java程序运行的虚拟机吗？这一段代码就会让jvm虚拟机自动退出
        }finally{
            System.out.println("欢迎来到finally语句体内部，我被执行了");
        }
    }

}
/*除数为0*/

注意：
A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

    上述仅仅针对编译时期异常
    与运行时期异常无关。

throw和throws的区别？
throws:
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常

throw:
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常?

案例：编译时期异常(文件未找到异常)和运行时期异常(除数为0异常)使用上的区别
throw:
如果throw的是编译时期异常，在方法声明上必须用throws进行标记
如果throw的是运行时期异常，在方法声明上可以用throws进行标记，也可以不用。

public class ThrowDemo {
    public static void main(String[] args) {


    }

    public static void  method(){
        int a  = 10;
        int b = 2;
        //System.out.println(a/b);
        if (b==0) {
            //如果抛出的异常是一个运行时期异常的话，方法声明上使用throws进行声明，也可以不声明
            throw new ArithmeticException();
        }else {
            System.out.println(a/b);
        }
    }

    public static void  method2() throws FileNotFoundException{
        try {
            FileInputStream fis = new FileInputStream("D://a.txt");
        } catch (FileNotFoundException e) {
            //在catch块里面使用抛出此异常的方式处理该异常
            //如果抛出的异常是一个编译时期异常的话，就必须在方法声明上使用throws进行声明
            throw new FileNotFoundException();
        }

    }

}