Java-异常

最新推荐文章于 2021-11-12 17:09:10 发布

csdnyp

最新推荐文章于 2021-11-12 17:09:10 发布

阅读量120

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_39768411/article/details/108538340

版权

在这里插入图片描述

java.util.Throwable:类是Java语言中所有错误和异常的超类
Exception:编译器异常，进行编译(写代码)java程序出现的问题
RuntimeException：运行期异常，java程序运行过程中的问题
Error:错误
必须修改源代码，程序才能执行
在这里插入图片描述

throw：

package dl.java.day11.demo04;
/*
    Throw关键字：
    作用：
        可以使用throw关键字在指定的方法中抛出指定的异常
    使用格式：
        throw new xxxException("异常产生的原因")；
    注意：
        1.throw关键字必须写在方法内部
        2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
        3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
            throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，默认交给JVM处理(打印异常处理，中断程序)
            throw关键字后边创建的是编译异常，我们必须处理异常，要么throw，哟啊吗try...catch...
 */
public class Throw {
    public static void main(String[] args) {
        //int[] arr = null;
        int[] arr = new int[3];
        //int e = getElement(arr, 0);
        int e = getElement(arr, 3);
        System.out.println(e);//NullPointerException                  ArrayIndexOutOfBoundsException
    }
    //首先必须对方法传递过来的参数进行合法性校验
    //如果参数不合法，那么必须使用抛出异常，告知方法调用者，传递的参数有问题
    //注意：NullPointerException是一个运行期异常，无需处理，默认JVM处理
    //ArrayIndexOutOfBoundsException是一个运行期异常，无需处理，默认JVM处理
    public static int getElement(int[] arr,int index) {
        /*
            对传递过来的参数数组，进行合法性校验
            如果数组arr为null
            那么抛出空指针异常，告知方法调用者"传递的数组的值为null"
         */
        if (arr == null){
            throw new NullPointerException("传递参数为空");
        }
        /*
            对参数index进行合法性校验
            index不在数组索引范围内
            抛出数组索引越界异常，告知方法调用者"传递的索引越界了"
         */
        if (index < 0 || index > arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引越界了");
        }
        int ele = arr[index];
        return ele;
    }
}

Objects非空判断：
在这里插入图片描述

package dl.java.day11.demo04;

public class Objects {
    public static void main(String[] args) {
        method(null);//NullPointerException
    }
    public static void method(Object obj){
        //对传递过来的参数进行合法性判断，判断是否为null
        if (obj == null){
            throw new NullPointerException("传递的对象为空");
        }

    }
}

简化参数的合法判断：
简化参数合法性判断
声明异常throws：(异常处理的第一种方式) 直接中断程序

package dl.java.day11.demo04;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
    throws关键字：异常处理的以一种方式，交给别人处理
    作用：
        当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
        可以使用throws关键字处理异常对象，会把异常对象抛出给方法的的调用者处理，最终交给JVM处理---》中断处理
    使用格式：再方法声明时使用
        修饰符 返回值类型  方法名(参数列表)throws AAAException,BBBException{
            throw new AAAException("产生原因");
            throw new BBBException("产生原因");
        }
    注意：
        1.throws关键字必须写在方法声明处
        2.throws关键字后边声明的异常必须是Exception或者是Exception的子类
        3.方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常
            如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
        4.调用了一个声明异常的方法，我们就必须处理声明的异常
            要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
            要么使用try...catch 自己处理异常
 */
public class Throws {
    //FileNotFoundException extends IOException extends Exception
    // 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
    //public static void main(String[] args) throws FileNotFoundException,IOException {
    public static void main(String[] args) throws IOException {
        readFile("c:\\\\a.txt");
    }
     /*
    定义一个方法，对传递的文件路径进行合法性判断
    如果路径不是“c:\\a.txt”，那么我们就抛出文件找不到异常对象，告知方法的调用者
        FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常
        可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
     */
    //public static void readFile(String fileName) throws FileNotFoundException,IOException{
    public static void readFile(String fileName) throws IOException{
        if (!fileName.equals("c:\\\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }
        /*
            如果传递的路劲，不是.txt结尾
            那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
         */
        if (!fileName.endsWith(".txt")){
            throw  new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

try_catch_(异常处理的第二种方式)：可以继续执行后续代码

package dl.java.day11.demo04;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
    try...catch...:异常处理的第二种方式，自己处理异常
    格式：
        try{
            可能产生异常的代码
        }catch(定义一个异常的变量，用来接收try中抛出的异常对象){
            异常处理逻辑，产生异常对象之后，怎么处理异常对象
            一般在工作中，会把异常的信息记录到日志中
        }
        ...
        catch (异常类名 变量名){

        }
    注意：
        1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常
        2.如果try中产生了异常，就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try...catch之后的代码
            如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try...catch之后的代码
 */
public class TryCatch {
    public static void main(String[] args) {
        try {
            readFile("d:\\a.tx");
        }catch (IOException e){//try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            System.out.println("catch传递的文件后缀不是.txt");
        }
        System.out.println("后续代码");

    }
    /*
            如果传递的路劲，不是.txt结尾
            那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
    */
    public static void readFile(String fileName) throws IOException{
        if (!fileName.endsWith(".txt")){
        throw  new IOException("文件的后缀名不对");
    }
        System.out.println("路径没有问题，读取文件");
}
}

在这里插入图片描述
Throwable类： getMessaget toString printStackTrace

public class TryCatch {
    public static void main(String[] args) {
        try {
            readFile("d:\\a.tx");
        }catch (IOException e){//try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            //System.out.println("catch传递的文件后缀不是.txt");

            /*
                Throwable类中定义了三个异常处理方法
                String getMessage() 返回throwable的简短描述
                String toString() 返回throwable 的详细消息字符串
                void printStackTrace() JVM打印异常对象，默认调用此方法，打印异常信息最全面
             */
            System.out.println(e.getMessage());//文件的后缀名不对
            //System.out.println(e.toString());//重写Object类的toString java.io.IOException: 文件的后缀名不对
            System.out.println(e);
            e.printStackTrace();
            /*
            java.io.IOException: 文件的后缀名不对
	        at dl.java.day11.demo04.TryCatch.readFile(TryCatch.java:52)
	        at dl.java.day11.demo04.TryCatch.main(TryCatch.java:27)
             */
        }
        System.out.println("后续代码");

    }
    /*
            如果传递的路劲，不是.txt结尾
            那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
    */
    public static void readFile(String fileName) throws IOException{
        if (!fileName.endsWith(".txt")){
        throw  new IOException("文件的后缀名不对");
    }
        System.out.println("路径没有问题，读取文件");
}
}

finally 代码块：

package dl.java.day11.demo04;

import java.io.IOException;

/*
    finally代码块:
    格式：
        try{
            可能产生异常的代码
        }catch(定义一个异常的变量，用来接收try中抛出的异常对象){
            异常处理逻辑，产生异常对象之后，怎么处理异常对象
            一般在工作中，会把异常的信息记录到日志中
        }
        ...
        catch (异常类名 变量名){

        }finally{
            无论出现异常都会执行
        }
    注意：
        1.finally不能单独使用，必须和try一起使用
        2.finally一般用于资源释放(资源回收)，无论程序是否出现异常，最后都要资源释放(IO)
 */
public class Finally {
    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            readFile("c:\\a.tx");
        } catch (IOException e) {
            //异常的处理逻辑
            e.printStackTrace();
        }finally {
            //无论是否出现异常，都会执行
            System.out.println("资源释放");
        }
    }
    /*
            如果传递的路劲，不是.txt结尾
            那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
    */
    public static void readFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")){
            throw  new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }

}

在这里插入图片描述
异常注意事项：

1.多个异常分别处理

 //1.多个异常分别处理
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        }

        try {
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        }

2.多个异常一次捕获，多次处理
在这里插入图片描述

3.多个异常一次捕获一次处理
在这里插入图片描述

finally语句中不能有return语句

子父类异常：

package dl.java.day11.demo05;

import dl.java.day11.demo05.Exception;

/*
    如果finally有return语句，永远返回finally中的结果，避免该情况
 */
/*
子父类的异常：
    如果父类抛出多个异常，子类重写父类方法时，抛出和父类相同的异常或者父类异常的子类或者不抛出异常
    父类没有抛出异常，子类重写父类该方法时也不可抛出异常，此时子类产生该异常，只能捕获异常，不能声明抛出
 注意：
    父类异常什么样，子类异常什么样
 */
public class Fu {
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04() throws Exception {}
}
class Zi extends dl.java.day11.demo05.Fu {
    //子类重写父类方法时，抛出和父类相同的异常
    public void show01() throws NullPointerException,ClassCastException{}
    //子类重写父类方法时，抛出和父类异常的子类
    public void show02() throws ArrayIndexOutOfBoundsException{}
    //子类重写父类方法时，不抛出异常
    public void show03(){}

    /*
        父类没有抛出异常，子类重写父类该方法时也不可抛出异常
     */
    //public void show04() throws Exception{}

    //此时子类产生该异常，只能捕获异常，不能声明抛出
    public void show04(){
        try {
            throw new Exception("编译器异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

自定义类型：
在这里插入图片描述

package dl.java.day11.demo05;
/*
    自定义异常类：
        java提供的异常类，不够我们使用，需要自己定义一些异常类
    格式：
        public class xxxException extends Exception | RuntimeException{
            添加一个空参数的构造方法
            添加一个带异常信息的构造方法
        }
    注意：
        1.自定义异常类一般都是以Exception结尾，说明该类是一个异常类
        2.自定义异常类，必须的继承Exception或者RuntimeException
            继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译器异常，
                          就必须处理这个异常，要么throws，要么try...catch
            继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理(中断处理)
 */
public class RegisterException extends Exception{
    //添加一个空参数的构造方法
    public RegisterException(){
        super();
    }
    /*
        添加一个带异常信息的构造方法
        查看源码发现，所有的异常类都会有一个带异常信息的构造方法，方法内部会调用父类带异常信息的构造方法，
        让父类来处理这个异常信息
     */
    public  RegisterException(String message){
        super(message);
    }
}


package dl.java.day11.demo05;

import java.util.Scanner;

/*
    要求：我们模拟注册操作，如果用户名存在，则抛出异常并提示：亲，该用户已被注册。
    分析：
        1.使用数组保存已经注册过的用户名(数据库)
        2.使用Scanner获取用户注册的用户名(前端，页面)
        3.定义一个方法，对用户输入的注册的用户名j进行判断
            遍历存储已经注册过用户名的数组， 获取每一个用户名
            使用获取到的用户名和用户输入的用户名比较
                true：用户名存在，抛出异常RegisterException，告知用户已经被注册
                false：继续遍历比较，循环完，提示注册成功
 */
public class RegisterException02 {
    //1.使用数组保存已经注册过的用户名(数据库)
    static  String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //2.使用Scanner获取用户注册的用户名(前端，页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要注册的用户名：");
        String username = sc.next();
        checkUsername(username);
    }

    //3.定义一个方法，对用户输入的注册的用户名j进行判断
    public static void checkUsername(String username) /*throws RegisterException*/ {
        //遍历存储已经注册过用户名的数组， 获取每一个用户名
        for (String name : usernames) {
            //使用获取到的用户名和用户输入的用户名比较
            if(name.equals(username)){
                //true：用户名存在，抛出异常RegisterException，告知用户已经被注册
                try {
                    throw new RegisterException("亲，该用户已被注册");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return;//结束方法
                }
            }
        }
        // false：继续遍历比较，循环完，提示注册成功
        System.out.println("恭喜您，注册成功");
    }
}