究竟什么是Java异常？

第四阶段 IO

异常处理

在我们开发过程中 我们运行时常常会遇到 这样java.lang.XxxException的信息，这代表程序发生了一些错误，也叫作异常

(一) 概述及体系

(1) 概述

异常情形是指阻止当前方法或者作用域继续执行的问题 ——《Think in Java》

简单概括：程序出现不正常情况后，程序将会跳出当前环境，并且抛出异常。

(2) 体系

(1) Error—— 错误 ：程序无法处理的严重错误，我们不作处理

• 这种错误一般来说与操作者无关，并且开发者与应用程序没有能力去解决这一问题，通常情况下，JVM会做出终止线程的动作

(2) Exception—— 异常 ：异常可以分为运行时异常和编译期异常

• RuntimeException：即 运行时异常 ，我们必须修正代码

  • 这些异常通常是由于一些逻辑错误产生的

    这类异常在代码编写的时候不会被编译器所检测出来，是可以不需要被捕获，但是程序员 也可以根据需要行捕获抛出，（不受检查异常）这类异常通常是可以被程序员避免的。

    常见的RUNtimeException有：NullpointException（空指针异常），ClassCastException （类型转 换异常），IndexOutOfBoundsException（数组越界异常）等。

• 非RuntimeException： 编译期异常 ，必须处理，否则程序编译无法通过

  • 这类异常在编译时编译器会提示需要捕获，如果不进行捕获则编译错误。
  • 常见编译异常有：IOException（流传输异常），SQLException（数据库操作异常）等。

Java内置异常类

A：Java 的非检查性异常

B：Java的检查性异常

(二) 异常处理语句

(1) try-catch

A：捕获单个异常

try{
    //程序代码
}catch (ExceptionName e1){
    //Catch块
}

B：多重捕获块

try{
    //程序代码
}catch (异常类型1 异常的变量名1){
    ......
}catch (异常类型2 异常的变量名2){
    ......
}catch (异常类型3 异常的变量名3){
    ......
}

try：用于监听异常

catch：用于捕获处理异常

try后面的一对大括号内的内容即受到监控的程序，也就是说这一段代码是可能存在异常的，而 Catch 中由开发者，根据自身推断可能存在的异常，书写对应异常类型以及处理方式，当程序发生异常时，会创建异常对象，并且将异常抛出到此环境外，Java运行时系统会寻找与发生异常所匹配的 catch 子句，当找到一个对应语句后则不再寻找其他catch块

public class Demo {
    public static void main(String[] args) {
        int a = 520;
        int b = 0;
        int c;

        try {
            System.out.println("这是一个被除数为0的式子");
            c = a / b;
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        }
    }
}

//运行结果
这是一个被除数为0的式子
除数不能为0

通过上例可以看到，被监控的语句中先依次正常执行，当遇到存在问题的语句时，找到匹配异常，并且执行catch块中的语句

而一般来说我们会在catch语句块中通过异常对象执行异常方法

我们还是用上面的例子给出异常方法的测试

System.out.println(e.getMessage());

/ by zero

System.out.println(e.getCause());

null

System.out.println(e.toString());

java.lang.ArithmeticException: / by zero

e.printStackTrace();

java.lang.ArithmeticException: / by zero
    at cn.bwh_01_Throwable.Demo.main(Demo.java:10)

(2) try-catch-finally

我们在 try-catch的基础上再补充一个finally的知识

finally 关键字用来创建在 try 代码块后面执行的代码块无论是否发生异常，finally 代码块中的代码总会被执行，在 finally 代码块中，可以运行清理类型等收尾善后性质的语句，finally 代码块出现在 catch 代码块最后，语法如下：

try{
    ......
}catch(异常类型1 异常的变量名1){
    ......
}catch(异常类型2 异常的变量名2){
    ......
}finally{
    ......
}

无论是否发生异常，fianlly始终都是会运行的

这里就不得不提一个非常重要的注意点，那就是当 return遇到finally ！

注意点

A：return遇到finally

我们来看下面一个例程：

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(test());
    }

    public static String test(){
        int[] array = new int[2];
        try{
            array[3] = 0;
            return "This is try";
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
            return "This is catch 1";
        }catch (Exception e){
            System.out.println(e);
            return "This is catch 2";
        }finally {
            System.out.println("This is finally");
            //return "This is finally's return";
        }
    }
}

//运行结果
java.lang.ArrayIndexOutOfBoundsException: 3
This is finally
This is catch 1

由此我们得出一个结论：在catch中遇到return时，仍然会先执行finally语句，再回来执行对应catch语句中的return语句

但是我们如果将finally中return行中的注释去掉，运行结果就会变成下面这样子

//运行结果
java.lang.ArrayIndexOutOfBoundsException: 3
This is finally
This is finally's return

结果就是返回值会被finally中的return语句重新覆盖

B：catch 顺序问题

public class Demo3 {
    public static void main(String[] args) {
        int[] array = new int[2];
        try{
            array[5] = 0;
        }catch (Exception e){

        }catch (ArrayIndexOutOfBoundsException e){

        }
    }
}

//运行结果
Error:(8, 10) java: 已捕获到异常错误java.lang.ArrayIndexOutOfBoundsException

对于多个catch的情况，当try中程序发生异常，会按照从上往下的顺序与catch进行匹配，一旦与其中一个匹配后就不会再与后面的catch进行匹配了，所以， 在书写catch语句的时候，一定要把范围小的放在前面，范围大的放在后面！

(3) throw/throws

将自己处理不了的，在方法或者语句上声明，告诉调用者，这里有问题

如果一个方法没有捕获到检查性异常，那么该方法就必须使用throws关键字声明（声明抛出多个异常，之间使用逗号隔开），也可以在语句中使用throw关键字抛出一个异常。

//演示throw
public class Demo4 {
    public static void main(String[] args) {
        test();
    }

    public static void test() {
        int a = 520;
        int b = 0;
        if (b == 0) {
            throw new ArithmeticException();
        } else {
            System.out.println(a / b);
        }
    }
}

//运行结果
Exception in thread "main" java.lang.ArithmeticException

//演示throws

public class Demo4 {
    public static void main(String[] args) {
        try {
            test();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void test() throws Exception {
        int a = 520;
        int b = 0;
        if (b == 0) {
            throw new Exception();
        } else {
            System.out.println(a / b);
        }
    }
}

//运行结果
java.lang.Exception

throws和throw的区别

A：throws

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

B：throw

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

(三) 自定义异常

Java内置的异常类，基本可以满足我们在编程中遇到的大部分异常情况，此外我们还可以自定义异常类，只需要继承Exception类即可

基本步骤：

• 创建自定义异常类

• 在方法中通过throw抛出异常对象

  • 在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获处理
  • 也可以在方法声明处使用throws将异常抛给方法调用者
• 在出现异常方法的调用者中捕获并且处理异常

class MyException extends Exception {  // 自定义的类
    MyException(String s) {
        super(s);
    }
}
class Demo {
    void method() throws MyException {
        throw new MyException("Wrong"); // 抛出自定义的类
    }
}
class DemoTest {
    public static void main(String[] args){
        try {
            new Demo().method();
        }
        catch(MyException e) {
            System.out.println(e.getMessage());
        }
    } 
}

//运行结果
Wrong

(三) 总结

异常就是在程序发生异常时，强制终止程序运行，并且将异常信息返回，由开发者决定是否处理异常

简单说一下这个异常机制的过程：

当程序无法运行后，它会从当前环境中跳出，并且抛出异常，之后，它会先new一个异常对象，然后在异常位置终止程序，并且将异常对象的引用从当前环境中返回，这时候异常处理机制接管程序，并且开始寻找可以继续执行程序的恰当位置。

结尾：

如果内容中有什么不足，或者错误的地方，欢迎大家给我留言提出意见, 蟹蟹大家 ！^_^

如果能帮到你的话，那就来关注我吧！（系列文章均会在公众号第一时间更新）

一个坚持推送原创Java技术的公众号：理想二旬不止