Java小白入门到实战应用教程-异常处理

Java小白入门到实战应用教程-异常处理

前言

我们这一章节进入到异常处理知识点的学习。异常是指程序在运行时遇到的一种特殊情况，它能打断了正常的程序执行流程。

而异常处理是一项至关重要的技术，它使得程序能够优雅地处理运行时错误，避免程序崩溃，并且我们可以结合日志打印等动作可以排查一些线上环境产生的问题。

在java中关于异常的结构如下，我随便从网上找了一张结构图：

java中异常的结构如上图所示，所有异常最上层是Throwable，是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception

Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表： StackOverflowError和OutOfMemoryError，一旦发生程序就崩溃

Exception ： 异常产生后我们可以通过代码进行处理，使程序继续执行。

而Exception 又往下划分为编译异常和运行时异常。

编译异常比如上面图提到的ClassNotFoundException、IOException等，这类异常一旦存在程序在编译阶段就会被发现，是我们必须处理的异常。

运行时异常则是不容易被发现的异常，指的是在程序运行过程中可能产生的异常。

正文

因为Error不常遇到，编译异常在编译阶段就能被发现，所以需要我们做异常处理的通常指的是运行时异常。

Java的异常处理机制主要通过try、catch、finally以及throw、throws关键字来实现。

• try-catch：将可能抛出异常的代码放在try块中，并通过一个或多个catch块来捕获并处理这些异常。每个catch块都指定了要捕获的异常类型及其处理逻辑。
• finally：finally块是可选的，但它总是会在try块或catch块之后执行，无论是否捕获到异常，也无论try/catch块中是否有return语句。finally块通常用于释放资源，如关闭文件流、数据库连接等。
• throw：用于显式地抛出异常。可以在方法内部使用throw关键字抛出一个异常对象，将错误向上传递给调用者。
• throws：如果一个方法可能会抛出检查型异常，但又不打算在方法内部处理这个异常，那么可以在方法声明时使用throws关键字声明这个异常，让方法的调用者负责处理。

try-catch

样例

登录后复制

public class Demo {

    public static void test(){
        String name = null;
        System.out.println("结果是："+name.equals("111"));
    }

    public static void main(String[] args) {
        test();
        System.out.println("结束");
    }
}

//运行结果
Exception in thread "main" java.lang.NullPointerException
	at com.example.exceptions.Demo.test(Demo.java:15)
	at com.example.exceptions.Demo.main(Demo.java:19)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.

解释：在上面的Demo中我们定义了一个test方法，在test中我们声明了一个String变量name，然后输出了一下name的值是否为’111’.

因为name变量值为null，所以name.equals(“111”)就会抛异常了，然后程序就会中断，所以最后一句”结束“没有执行。

所以我们针对这个样例来做一个异常处理：

登录后复制

public class Demo {

    public static void test(){
        String name = null;
        boolean equals = true;
        try {
            equals = name.equals("111");
        }catch (Exception e){
            e.printStackTrace();
            equals = false;
            System.out.println("name.equals(\"111\")这句代码抛异常了，被try catch块捕获到了");
        }

        System.out.println("结果是："+equals);
    }

    public static void main(String[] args) {
        test();
    }
}
//运行结果
java.lang.NullPointerException
	at com.example.exceptions.Demo.test(Demo.java:17)
	at com.example.exceptions.Demo.main(Demo.java:28)
name.equals("111")这句代码抛异常了，被try catch块捕获到了
结果是：false

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.

解释：我们通过try catch块去做异常处理，我们知道 name.equals(“111”)这句代码可能会发生异常，所以把这句代码放到try块中监控起来，然后在catch块中去捕获产生的异常，catch后面()中为我们要捕获异常的类型，我们这里写的Exception，因为Exception是所有运行异常的最上级，所以可以捕获所有的运行时异常。

然后再catch块中，我们通过e.printStackTrace();打印了一下捕获到的异常的堆栈信息，然后在下面写了两句业务的处理代码。

finally

我们在前面还提到了finally关键字，是可选的，但如果写了finally块，它总是会在try块或catch块之后执行，无论是否捕获到异常。

下面我们将finally块加到上面的代码中：

登录后复制

public class Demo {

    public static void test(){
        String name = null;
        boolean equals = true;
        try {
            equals = name.equals("111");
        }catch (Exception e){
            e.printStackTrace();
            equals = false;
            System.out.println("name.equals(\"111\")这句代码抛异常了，被try catch块捕获到了");
        }finally {
            System.out.println("finally块执行！");
        }

        System.out.println("结果是："+equals);
    }

    public static void main(String[] args) {
        test();
    }
}
//运行结果：
java.lang.NullPointerException
	at com.example.exceptions.Demo.test(Demo.java:17)
	at com.example.exceptions.Demo.main(Demo.java:30)
name.equals("111")这句代码抛异常了，被try catch块捕获到了
finally块执行！
结果是：false

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.

throws

在上面的样例中我们直接在test方法源码处处理了异常，但是有的时候我们需要在函数的调用者处去处理异常，然后获取到异常的一些信息。所以针对这样的情况，java中可以通过关键字throws去实现。

throws关键字的作用就是将此处产生的异常往上层抛，抛给调用者，然后调用者可以通过try catch去捕获异常然后进行处理。

我们将上面样例修改一下，直接看样例：

登录后复制

public class Demo {

    public static void test() throws Exception{
        String name = null;
        System.out.println("结果是："+name.equals("111"));
    }

    public static void main(String[] args) {
        try {
            test();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("test函数发生异常");
        }
        System.out.println("结束");
    }
}
//输出结果
java.lang.NullPointerException
	at com.example.exceptions.Demo.test(Demo.java:15)
	at com.example.exceptions.Demo.main(Demo.java:20)
test函数发生异常
结束

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.

解释：我们可以看到在test方法声明后面我们通过关键字throws抛出了Exception，意思就是将Exception及它的子类异常都抛给方法的调用者。

然后我们在main函数中通过try catch将test()方法的调用语句进行监控起来了，然后程序运行的时候就能捕获test方法产生并抛出的异常。

throw

在前面的所有样例中，我们的异常都是程序运行产生的，其实我们还可以手动去抛出异常。手动抛出异常的应用场景通常是我们经过判断后觉得后面的程序不需要运行，并且需要输出一些原因。

通过return关键字也能实现中断方法继续运行的效果，但是如果输出一些日志啥的效果还得再加一些代码，但是通过手动抛出异常可以一举两得。

样例代码

登录后复制

public class Demo {

    public static void test() throws Exception{
        String name = "000";
        boolean equals = name.equals("111");
        if (!equals){
            throw new RuntimeException("name的值不是111，不继续运行后面的逻辑");
        }
        name = "222";
    }

    public static void main(String[] args) {
        try {
            test();
        } catch (Exception e) {
            System.out.println("test函数发生异常:"+e.getMessage());
        }
        System.out.println("结束");
    }
}
//结果输出：
test函数发生异常:name的值不是111，不继续运行后面的逻辑
结束

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.

解释：我们在test方法中做了个判断当name的值不等于111的时候就手动抛出了一个运行时异常，异常中的message内容为：name的值不是111，不继续运行后面的逻辑。

如果name的值等于111，就将name的值修改为222.

然后我们在main函数中去捕获test方法的异常，并在catch块中将捕获的异常的message的内容进行了打印。

原创作者: u_13145529 转载于: https://blog.51cto.com/u_13145529/11740591