Java基础知识（三十）IO流（一）Java中的异常及处理

L缶神

已于 2022-02-17 20:47:17 修改

阅读量771

点赞数

分类专栏： java 文章标签： java 开发语言后端

于 2022-02-17 09:50:08 首次发布

本文链接：https://blog.csdn.net/qq_45986314/article/details/122975492

版权

java 专栏收录该内容

55 篇文章 18 订阅

订阅专栏

异常

1、异常的分类

2、处理异常的两种方法

try...catch...finally

异常

Java程序出现不正常的情况

1、异常的分类

Java中的异常：Throwable

严重的问题：Error，我们不处理，这样的问题一般都是很严重的，比如说内存溢出（OOM）

问题：Exception（异常）分为编译时期异常与运行时期异常

编译时期异常：除了RuntimeException都是编译时期异常，必须要处理，如果不处理，程序编译无法通过，无法运行

运行时期异常：RuntimeException，这样的问题，一般情况下，我们不会对问题本身进行处理，因为这样的问题是在自己写代码的过程中由于逻辑的不严谨导致的。

如果程序出现了问题，并且我们没有做任何处理，最终JVM会做出默认处理，把异常的名称，相关的原因，以及出现问题的信息输出在控制台上，同时程序会停止，而且后续的代码不会执行。

异常的分类图解：

2、处理异常的两种方法

1、try...catch...finally

2、throws

try...catch...finally

try...catch...finally的处理格式：

try{
可能会出现问题的代码

}catch(异常类名变量名){
针对出现问题后的处理代码

}finally{
只要是程序顺利进行，finally中的内容无论如何都会执行

}

变形格式：

try{

可能会出现问题的代码

}catch(异常类名变量名){

针对出现问题后的处理代码

}

注意：try中的代码越少越好；catch中必须要有内容，即使内容只是一句简单的提示语句

以除数为0举例：

当在代码中直接输出10除以0时，编译不会出现异常，但运行会出现异常，即出现运行时期异常。

加入try...catch处理异常：

public class Demo1 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        
        try{
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println("除数为0，无法相除");
        }
    }
}

输出结果：

上述是处理一个异常的情况，当处理两个及以上个异常的情况时，有两种做法：

1、每一个异常写一个try..catch

2、写一个try，多个catch：

第二种做法格式为：

try{

可能会出现问题的代码

}catch(异常类名1 变量名1){

针对异常1做的处理方案

}catch(异常类名2 变量名2){

针对异常2做的处理方案

}... ...

当处理多个异常使用第二种方案时的注意事项：

1、catch只能匹配对应的异常，并且只能匹配一个异常

2、平级关系的异常顺序无所谓，但如果出现了父子继承关系，父类必须放在最后

3、try中的代码如果出错了，try中出错代码后面的代码不会执行，就会匹配catch中的异常，匹配到后执行解决方案，try...catch后面的代码正常执行。

4、catch中的异常类名尽量明确，不要用大的异常去处理

代码举例：

public class Demo2 {
    public static void main(String[] args) {
        fun();
    }
    public static void fun(){
        int a=10;
        int b=0;
        int[] arr={1,2,3};
 
        try{
            System.out.println(a/b);
//            执行到此处，报错，直接匹配catch，try中此行后面的代码不执行
            System.out.println(arr[4]);
        }catch(ArithmeticException e){
            System.out.println("除数为0，无法相除");
        }catch(ArrayIndexOutOfBoundsException s){
            System.out.println("下标索引越界");
        }
        System.out.println("over");
    }
}

输出结果：

JDK1.7之后出现的处理多个异常的方式：

try{

可能出现问题的代码

}catch(ArithmeticException | ArrayIndexOutOfBoundsException){

处理问题的方案

}

注意事项：

1、处理方式是一致的，这个方式虽然简洁，但是也不够好，针对多种数据类型的异常，只给出了一种解决方案

2、这样的方式，catch中只能写平级关系的异常类

举例：

public class Demo3 {
    public static void main(String[] args) {
        fun();
    }
    public static void fun(){
        int a=10;
        int b=0;
        int[] arr={1,2,3};
 
        try{
            System.out.println(a/b);
            System.out.println(arr[4]);
        }catch(ArithmeticException | ArrayIndexOutOfBoundsException e){
            System.out.println("有错误，报错了");
        }
        System.out.println("over");
    }
}

输出结果：

代码举例：编译时期异常举例：

使用

日期类举例：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class ExceptionDemo5 {
    public static void main(String[] args) {
        //日期转化
        String s = "2022-02-16 15";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
        try{
            Date date = sdf.parse(s);
            System.out.println(date);
        }catch (ParseException e){
            System.out.println("日期转换异常");
        }
 
        System.out.println("over");
    }
}

输出结果：

编译时期异常与运行时期异常的区别：

编译时期异常：Java程序必须要显示的处理，否则程序就会发生错误，无法通过编译，不能运行

运行时期异常：一般情况下，不去处理，修改代码逻辑，也可和编译时期异常一样使用try...catch处理

Throwable中的方法

getMessage() 获取异常信息，返回字符串。

toString() 获取异常类名和异常信息，返回字符串。

printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

代码举例：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class Demo4 {
    public static void main(String[] args) {
        String s = "2022-02-16 15";
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
        try {
            Date date = format.parse(s);
            System.out.println(date);
        } catch (ParseException p) {
            p.printStackTrace();
            String message = p.getMessage();
            System.out.println(message);//Unparseable date: "2022-02-16 15"
 
            String s1 = p.toString();
            System.out.println(s1);//java.text.ParseException: Unparseable date: "2022-02-16 15"
 
 
        }
        System.out.println("over");
    }
}

输出结果：红色字体为p.printStackTrace()输出结果，其余依次为其他两种方法的结果

finally

finally: 被finally控制语句体最终一定会执行，特殊情况除外

特殊情况：在执行finally控制语句体之前，JVM就退出了

格式：try...catch...finally

代码举例：

public class Demo6 {
    public static void main(String[] args) {
        //日期转化
        String s = "2022-02-16 16:";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
        Date date = null;
 
        try {
            date = sdf.parse(s);
        }catch (ParseException e){
            e.printStackTrace();
        }finally {
            //一般情况下，finally里面写的是用于
            //IO操作和针对于数据库操作，经常遇见
            System.out.println("这里的代码一定会执行！");
        }
 
        System.out.println(date);
    }
}

输出结果：

若是让finally不执行，也就是实现特殊情况，只需要在finally执行前加入停止代码即可

public class FinallyDemo1 {
    public static void main(String[] args) {
        //日期转化
        String s = "2022-02-16 16:";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
        Date date = null;
 
        try {
            date = sdf.parse(s);
        }catch (ParseException e){
            e.printStackTrace();
            System.exit(0); //让程序停止
        }finally {
            //一般情况下，finally里面写的是用于
            //IO操作和针对于数据库操作，经常遇见
            System.out.println("这里的代码一定会执行！");
        }
 
        System.out.println(date);
    }
}

输出结果：

这里就是仅仅输出异常，没有执行finally中的内容。

final,finally和finalize的区别

final: 最终的意思，可以修饰类，成员变量，成员方法

修饰类：类不能被继承

修饰成员变量：变量变常量

修饰成员方法：方法不能被重写

finally: 是属于处理异常try...catch..finally的一部分，一般是用于释放资源，正常情况下，都会执行，除非在执行finally之前，程序停止。

finalize: 是Object类中一个方法，是用于垃圾回收的，堆内存中的空间没有栈的引用指向它，但是什么时候回收我们不确定。

throws

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。Java提供了另一种处理异常方案：

throws 抛出

语句定义格式：

throws 异常类名

注意：

1、这个格式必须要跟在方法的小括号后面，大括号前面

2、尽量不要在main方法上面抛出

总结：

1、编译时期异常抛出，将来调用者必须做处理

2、运行时期异常抛出，将来调用者依旧要做处理

代码举例：未作处理

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class Demo5 {
    public static void main(String[] args) throws ParseException {
        System.out.println("今天天气真好");
 
        fun();
 
        System.out.println("可以出去郊游");
 
    }
 
    public static void fun() throws ParseException {
        //日期转化
        String s = "2022-02-16 15";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(s);
        System.out.println(date);
    }
}

输出结果：这里fun()方法抛出异常给调用者main方法，mian()方法未作处理，抛出异常给JVM，JVM不会做处理，所以结果仍然是异常。

代码举例：抛出异常后调用者做了处理

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class Demo5 {
    public static void main(String[] args) throws ParseException {
        System.out.println("今天天气真好");
        try {
            fun2();
        }catch (ArithmeticException e){
            e.printStackTrace();
        }
 
        System.out.println("可以出去郊游");
 
    }
 
    public static void fun2() throws ArithmeticException{
        int a = 10;
        int b = 0;
        System.out.println(a/b);
    }
}

输出结果：报出异常，但是由于抛出后调用者main方法做了处理，所以后面的代码可以成功执行

throw

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

注意：此时用throw抛出的是异常类的对象

代码举例：

import java.text.ParseException;
 
public class ExceptionDemo8 {
    public static void main(String[] args) {
        try {
            fun();
        }catch (ArithmeticException e){
            e.printStackTrace();
        }catch (ParseException p){
            p.printStackTrace();
        }
 
        System.out.println("over");
    }
 
    public static void fun() throws ArithmeticException, ParseException {
        int a = 10;
        int b = 0;
 
        if(b==0){
            System.out.println("hello");
            throw new ArithmeticException();
        }else {
            System.out.println(a/b);
        }
    }
}

输出结果：

throws与throw的区别：

throws：

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

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

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

throws：

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

throw 用在方法体内，跟的是异常对象名

只能抛出一个异常对象名

表示抛出异常，由方法体内的语句处理 throw则是抛出了异常，执行throw则一定抛出了某种异常

如果catch里面有return语句，请问finally的代码还会执行吗? 会执行

如果会，请问是在return前还是return后。在之间执行。

代码举例：

public class ExceptionDemo9 {
    public static void main(String[] args) {
        System.out.println(getInt()); // 30
    }
 
    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a; // 走到这里就已经生成了一个返回路径 a=30;
        } finally {
            a = 40;
            System.out.println(a);
        }
 
        return a;
    }
}

输出结果：

结果解释：由于执行到第一个return a时就已经产生了一个返回路径，若是没有finally，则直接返回值30，但由于finally的内容无论怎么样都会执行，所以此时程序没有执行完，需要将finally执行完才算执行完毕，因此执行finally打印了40，执行完毕后回到main方法中打印了返回值30，第二个return a不会执行。

若是将第二个return a放入finally中，则结果会变成：

public class ExceptionDemo9 {
    public static void main(String[] args) {
        System.out.println(getInt()); // 30
    }
 
    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a; // 走到这里就已经生成了一个返回路径 a=30;
        } finally {
            a = 40;
            System.out.println(a);
            return a;
        }
    }
}

结果解释：此时执行finally前的步骤与前面相同，当执行到finally时，先打印40，在return a，此时又生成了一个返回路径，所以这里返回最后的一次返回路径，故又输出40

L缶神

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识（三十）IO流（一）Java中的异常及处理

异常1、异常的分类2、处理异常的两种方法try...catch...finally编译时期异常与运行时期异常的区别：Throwable中的方法finallythrowsthrowthrows与throw的区别：
复制链接

扫一扫

专栏目录