java异常总结

青春447

已于 2023-01-22 21:35:50 修改

阅读量283

点赞数

CC 4.0 BY-SA版权

文章标签： java

于 2022-04-05 22:07:57 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_65607252/article/details/123978611

异常

java异常处理机制

java中所有错误的超类为:Throwable，其下有两个子类:Error和Exception
Error的子类描述的都是系统错误，比如虚拟机内存溢出等。
Exception的子类描述的都是程序错误，比如空指针，下标越界等。
通常我们程序中处理的异常都是Exception。

1.1 异常处理机制中的try-catch

1.11 语法

try{

第一个xxx填写出现的异常类型

}catch(xxxException e){

try中出现xxxException后处理的代码

}

try语句块不能独立存在，后面必须跟catch语句块或finally语句块

1.12案例

package Thread;

/**
 * 异常处理机制中的try-catch
 * 语法:
 * try{
 * 第一个xxx填写出现的异常类型
 * }catch(xxxException e){
 * try中出现xxxException后处理的代码
 * }
 * try语句块不能独立存在，后面必须跟catch语句块或finally语句块
 */

public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");


        try {
            //String line = null;//空指针异常
            //String line = "";//下标越界异常
            String line = "abc";

            /*
                jvm执行到这里时如果发生了异常就会实例化一个对应的异常实例，并将程序执行
                过程设置进去，然后将异常抛出
             */


            System.out.println(line.length());
            System.out.println(line.charAt(0));//下标越界异常
            System.out.println(Integer.parseInt(line));//数字格式异常，不能转换为整数类型


//        } catch (NullPointerException e) {
//            System.out.println("出现了空指针异常");
//        }catch(StringIndexOutOfBoundsException e){
//            System.out.println("出现下标越界异常");

        } catch (StringIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("两种异常统一的解决办法");
        } catch (NumberFormatException e) {
            System.out.println("出现数字格式异常");
            //可以在最后一个catch出捕获Exception，避免因未捕获的异常导致程序中断
        } catch (Exception e) {
            System.out.println("通用错误的解决办法");
            e.printStackTrace();
        }
        System.out.println("程序结束了");


    }
}

1.2 异常处理机制中的finally块

finally块是异常处理机制的最后一块，它可以跟在try之后或者最后一个catch之后。

finally可以保证只要程序执行到try语句块，无论try中是否出现异常，finally最终都会必定执行。

通常我们将释放资源这类操作放在finally中确保运行，例如:IO操作后最终的close()调用。

1.21 案例一

package exception;

public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        try {
            String line = "abc";
            System.out.println(line.length());
            System.out.println(Integer.parseInt(line));
            //try语句块中出错代码以下的内容均不执行!
            System.out.println("!!!!");
            return;
        } catch (Exception e) {
            System.out.println("数字格式异常");
            //e.printStackTrace();
        } finally {
            System.out.println("finally在程序中执行了!");
        }
        System.out.println("程序结束了");


    }
}

1.22 案例二(异常处理机制在IO中的使用)

package exception;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 异常处理机制在IO中的使用
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("./fos.txt");
            // fos = new FileOutputStream("");
            fos.write(2);

        } catch (IOException e) {
            //e.printStackTrace();//把错误信息输入控制台
        } finally {
            try {
                /*
               if语句确保在发生路径异常不报错的情况下，顺利关流，null无法调用方法的
                若不判断就会发生NullPointerException异常
                 */
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

1.3 自动关闭特性

1.31 概念

JDK7之后，java推出了一个自动关闭特性,可以在异常处理机制中用更精简的写法完成IO的关闭操作

1.32 要求

只有实现了java.io.AutoCloseable接口的类才可以在这里定义并初始化,
编译器在编译代码的时候最终会将在这里定义的类在finally中调用close()关闭
注:最终编译完的样子可以参考FinallyDemo2.java的样子。

1.33 案例

package exception;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * JDK7之后，java推出了一个自动关闭特性
 * 可以在异常处理机制中用更精简的写法完成IO的关闭操作
 */

public class AutoCloseableDemo {
    public static void main(String[] args) {
        /**
         * 只有实现了java.io.AutoCloseable接口的类才可以在这里定义并初始化
         * 编译器在编译代码的时候最终会将在这里定义的类在finally中调用close()关闭
         * 注:最终编译完的样子可以参考FinallyDemo2.java的样子。
         */
        try (FileOutputStream fos = new FileOutputStream("fos.txt");) {
            fos.write(1);
            fos.close();//自动关闭流
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

上述代码是编译器认可的，而不是虚拟机。编译器在编译上述代码后会在编译后的class文件中改回成FinallyDemo2案例的代码样子(上次课最后的案例)。

1.4 throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常:

1.当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。

2.程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。

package exception;

public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception {
        if (age < 0 || age > 100) {
           // throw new RuntimeException("年龄不合法");
            /**
             * 当我们使用throw主动对外抛出一个异常时，出了RuntimeException之外
             * 其他异常抛出时必须在方法上使用throws声明该异常的抛出
             */
            throw new Exception("年龄不合法");
        }
        this.age = age;
    }
}

package exception;

/**
 * 异常的抛出
 * throw关键字可以主动对外抛出一个异常
 * 通常:
 * 1:程序出了异常，但是该异常不应当在当前代码块中被解决时，可以主动将其抛出去
 * 2:程序可以运行，但是以不满足业务场景要求时可以当作异常抛出去。
 */

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

        System.out.println("程序开始了");
        Person p = new Person();
        //满足语法但是不满足业务场景
        try {
            /*
                当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理
                这个异常，否则编译不通过。
                处理方式有两种:
                1:使用try-catch主动捕获并处理这个异常
                2:使用throws继续将该异常声明并抛出
             */

            p.setAge(200);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("此人年龄:" + p.getAge() + "岁");
        System.out.println("程序结束了");
    }

}

1.5 throws关键字

1.51 概念

当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。

package exception;

/**
 * 测试异常的抛出
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    /**
     * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
     */
    public void setAge(int age) throws Exception {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

1.52 处理方式

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过。处理手段有两种:

使用try-catch捕获并处理这个异常
在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。具体选取那种取决于异常处理的责任问题。

注意:永远不应当在main方法上使用throws!!

package exception;

/**
 * throw关键字，用于主动对外抛出一个异常
 */
public class ThrowDemo {
    public static void main(String[] args){
        System.out.println("程序开始了...");
        try {
            Person p = new Person();
            /*
                当我们调用一个含有throws声明异常抛出的方法时,编译器要求
                我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
                1:使用try-catch捕获并处理异常
                2:在当前方法上继续使用throws声明该异常的抛出
                具体用哪种取决于异常处理的责任问题
             */
            p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
            System.out.println("此人年龄:"+p.getAge()+"岁");
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("程序结束了...");
    }
}

1.53 含有throws的方法被子类重写时的规则

三种允许:

允许仅抛出部分异常
允许不再抛出任何异常
允许抛出超类方法抛出异常的子类型异常

二种不允许:

不允许抛出额外异常:超类没有的，且没有继承关系的
不允许抛出超类方法抛出异常的超类型异常

package exception;

import java.awt.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

/**
 * 子类重写超类含有throws声明异常抛出的方法时，对throws的重写规则
 */
public class ThrowsDemo {
    public void dosome()throws IOException, AWTException {}
}

class SubClass extends ThrowsDemo{
//    public void dosome()throws IOException, AWTException {}

    //允许仅抛出部分异常
//    public void dosome()throws IOException{}

    //允许不再抛出任何异常
//    public void dosome(){}

    //允许抛出超类方法抛出异常的子类型异常
//    public void dosome()throws FileNotFoundException {}

    //不允许抛出额外异常:超类没有的，且没有继承关系的
//    public void dosome()throws SQLException {}

    //不允许抛出超类方法抛出异常的超类型异常
//    public void dosome()throws Exception {}
}

1.6 异常的分类

1.61 可检测异常

可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译

1.62 非检测异常：

非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常

RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。

常见的RuntimeException子类

IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数
NullPointerException：当应用程序试图在需要对象的地方使用 null 时，抛出该异常
ArrayIndexOutOfBoundsException：当使用的数组下标超出数组允许范围时，抛出该异常
ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常
NumberFormatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。

1.7 异常中常用的方法

package exception;

/**
 * 异常中常用的方法
 */

public class ExceptionAPIDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        String str = "abc";
        try {
            System.out.println(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            e.printStackTrace();//1.输出错误信息有助于我们debug
            
            //2.获取错误消息，一般用于提示给用户或者记录日志的时候使用
            String message = e.getMessage();
            System.out.println(message);
            System.out.println("出错了，正在解决....");
        }

        System.out.println("程序结束了");
    }
}

1.8 自定义异常

自定义异常通常用来定义那些业务上的异常问题。

定义自定义异常需要注意以下问题:

异常的类名要做到见名知义
需要是Exception的子类
提供超类异常提供的所有种类构造器

package exception;

/**
 * 非法的年龄异常
 *
 * 自定义异常通常用来说明业务上的错误.
 * 自定义异常要注意以下问题:
 * 1:定义的类名要做到见名知义
 * 2:必须是Exception的子类
 * 3:提供Exception所定义的所有构造方法
 */
public class IllegalAgeException extends Exception{
    public IllegalAgeException() {
    }

    public IllegalAgeException(String message) {
        super(message);
    }

    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public IllegalAgeException(Throwable cause) {
        super(cause);
    }

    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

package exception;

/**
 * 测试异常的抛出
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    /**
     * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
     */
    public void setAge(int age) throws IllegalAgeException {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
//            throw new Exception("年龄不合法!");

            //抛出自定义异常
            throw new IllegalAgeException("年龄超范围:"+age);

        }
        this.age = age;
    }
}

package exception;

/**
 * throw关键字，用于主动对外抛出一个异常
 */
public class ThrowDemo {
    public static void main(String[] args){
        System.out.println("程序开始了...");
        try {
            Person p = new Person();
            /*
                当我们调用一个含有throws声明异常抛出的方法时,编译器要求
                我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
                1:使用try-catch捕获并处理异常
                2:在当前方法上继续使用throws声明该异常的抛出
                具体用哪种取决于异常处理的责任问题
             */
            p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
            System.out.println("此人年龄:"+p.getAge()+"岁");
        } catch (IllegalAgeException e) {
            e.printStackTrace();
        }

        System.out.println("程序结束了...");
    }
}