Java 对方不想跟你讲话 ，并向你抛出了一个异常

Java 面向对象篇

笔记首页

序号	内容	链接地址
1	面向对象概述	https://blog.csdn.net/weixin_44141495/article/details/107999131
2	类与对象	https://blog.csdn.net/weixin_44141495/article/details/107999182
3	继承	https://blog.csdn.net/weixin_44141495/article/details/107999261
4	重写与重载	https://blog.csdn.net/weixin_44141495/article/details/107999320
5	多态	https://blog.csdn.net/weixin_44141495/article/details/107999346
6	抽象	https://blog.csdn.net/weixin_44141495/article/details/107999379
7	封装	https://blog.csdn.net/weixin_44141495/article/details/107999404
8	包	https://blog.csdn.net/weixin_44141495/article/details/107999677
9	泛型	https://blog.csdn.net/weixin_44141495/article/details/108062785
10	异常	https://blog.csdn.net/weixin_44141495/article/details/108291361

Java异常概述

Java异常体系

Thorwable类（表示可抛出）是所有异常和错误的超类，两个直接子类为Error和Exception，分别表示错误和异常。

异常分类

• Error

  Error是程序无法处理的错误，它是由JVM产生和抛出的，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

• Exception

  Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。程序中应当尽可能去处理这些异常。

• 运行时异常

  运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

• 非运行时异常

  非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

抛出异常

处理异常的第一种方式是抛给别人，自己不处理，这里使用到Java的两个关键字throw和throws

throw

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

throws

• 用来声明一个方法可能产生的所有异常，不做任何处理而是将异常往上传，谁调用我我就抛给谁。

• 用在方法声明后面，跟的是异常类名

• 可以跟多个异常类名，用逗号隔开

• 表示抛出异常，由该方法的调用者来处理

• throws表示出现异常的一种可能性，并不一定会发生这些异常

代码实现

throw

当b=0时，我们也不处理这个异常了，直接让虚拟机线程停下来。

public static int division(int a,int b){
    
    if (b==0){
        throw new RuntimeException("不能除0");
    }
    else{
        return a/b;
    }
}

throws

这个文件可能不存在，那么我们读不到东西，就会出问题，我们可以把这个问题抛出去。

    public static int fileReader(int a,int b) throws IOException {
        
        FileInputStream fileInputStream = new FileInputStream("13.txt");
        int read = fileInputStream.read();
        fileInputStream.close();
        return read;
    }

当有人调用这个方法时，会给出提示，说这个方法可能会发生异常，需要我们处理异常，那么问题来了，我们这个异常抛来抛去没人处理啊。

我们知道main方法时程序入口，我们可以把异常抛给虚拟机，这样子我们至少程序编译通过。

但是如果这个异常发生了，就是文件找不到ClassNotFoundException，我们虚拟机就会报红字。

捕获异常

捕获异常是指我们处理出现的异常。涉及到try，catch，finally关键字

try-catch

我们的try中放可能出错的代码，catch的（）括号输入可能出现的异常，{}中输入异常发生时执行的代码，这里我们异常发生时，什么都不做。

public static void main(String[] args) {
    int[] ints=new int[10];
    
    try {
        ints[11]=10;
        
    }
    catch (ArrayIndexOutOfBoundsException e){
         System.out.println("角标越界了");
    }
    System.out.println("结束了");
}

运行结果

角标越界了
结束了

我们看到角标越界异常我们成功捕获了，并进行了一些处理（滑稽），让程序能正常运行。

多个异常

加入我们的代码可能有多处异常，那么我们需要分别捕获，我们可以一个try，多个catch

public static void main(String[] args) {
    int[] ints=new int[10];

    try {
        ints[11]=10;
        int i=1/0;

    }
    catch (ArithmeticException e){
        System.out.println("角标越界了");
    }
    catch (ArrayIndexOutOfBoundsException e){
        System.out.println("除0了");
    }
    System.out.println("结束了");
}

运行结果

由于角标越界先发生的，我们捕获到角标越界并打印，然后执行打印结束了的语句，程序结束。

角标越界了
结束了

交换顺序,则捕获了除0异常

        try {
            int i=10/0;
            ints[11]=10;
        }

除0了
结束了

这里有个注意事项！

就是Exception是也是Java的类，也有继承关系，当我们捕获多个异常的时候，前面的catch应该处理子类异常还是父类异常呢？

我们设想一下，ArrayIndexOutOfBoundsException是RuntimeException的子类，ArrayIndexOutOfBoundsException只表示角标越界的异常，而RuntimeException是所有运行时异常的父类，所以我们如果catch的前面是父类，那么子类在后面根本没机会捕获到异常。

Java实际上认为这种情况是错误的，报红字

当然我们顺序反过来就行了，如果不是角标越界异常，那么我们再交给权限更大的RuntimeException

优化

一般情况下，我们处理异常的方法是调用异常的printStackTrace方法。这个方法是让线程终止，然后在控制台打印一些错误的信息，一些细节

try {
            int i=10/0;
            ints[11]=10;

        }
        catch (ArithmeticException e){
            e.printStackTrace();
        }
        catch (RuntimeException e){
            e.printStackTrace();
        }

如果我们的异常都采用这种默认的处理方式，我们的catch语句块可以这么写。注意我们的这么写的前提是我们的异常都是同等级的，如果有继承关系，那么由于我们做了统一的管理，所以我们应该舍弃子类的异常。

public static void main(String[] args) {
    int[] ints=new int[10];

    try {
        int i=10/0;
        ints[11]=10;

    }
    catch (ArithmeticException | ArrayIndexOutOfBoundsException e){
        e.printStackTrace();
    }
    System.out.println("结束了");
}

try-catch-finnally

这是一种强化的结构，finally表示无论是否发送异常，我们都要执行的操作。

比如：

    public static void main(String[] args) {
        int[] ints = new int[10];
        FileInputStream input;
        
        try {
            input = new FileInputStream("123.txt");
        } 
        catch (FileNotFoundException e) {
            e.printStackTrace();
        } 
        finally {
            System.out.println("出错了");
        }
        System.out.println("结束了");
    }

结果

一般而言finally里放的是我们要执行结束动作的代码，比如IO关闭流，保存文件等等操作。在Jdk1.8我们有一种特殊的格式,来处理这个问题。

try()-catch

我们可以在try后加一个括号，将可能初始化失败的类实例化语句卸载try()后面的括号里面，如果这个123文件不存在，那么我们的input流也无法创建成功，那么也无需关闭了。但是如果创建成功了，因为我们的定义语句在try()的括号里面，Java虚拟机会自动帮我们关闭资源。

try (FileInputStream input=new FileInputStream("123")) {
    int read = input.read();
    System.out.println(read);
}
catch (IOException e){
    e.printStackTrace();
}

try-finnally

我们有try-catch结构，try-catch-finally结构，那这个结构是干什么的呢？

举个除法的例子，我们返回a/b如果b=0说明抛出了除零异常。那么我们直接指向finally里的方法。

public void division(int a,int b){
    try {
        int i= a/b;
        System.out.println("结果是"+i);
    }
    finally {
        System.out.println("出错了！");
    }
}

结果

异常还是发生了，但是我们发现我们的打印语句先执行了，也就是说，如果捕获到异常我们可以在finally里立刻执行一些操作，比如文件读取成功了，但是某一步出错了，我们可以立刻保存在备份的目录。

总结

• 异常分为两类，注意异常的继承关系的问题
• finally内的代码一定会执行吗？如果try里有System.exit()方法，或者线程被挂起，也是无法执行的
• finally如果有return语句，会在try的reuturn语句执行完毕，即将关闭这个方法的前，覆盖掉try里面的return的内容。
• 常规的异常处理方式就是e.printStackTrace()
• 我们可以自己写一个异常，实现Exception或者其他子类。