JavaEE开发重中之重 异常 捕获并抛出异常 自定义异常 2024详解

异常就是代表程序可能出现的问题

Error代表系统级别的错误

属于严重问题

Error是给sun公司用的，不是给程序员用的

Exception代表程序可能出现的问题

叫做异常

编译阶段不会出现异常提醒

运行时会出现的异常

编译阶段就会出现的异常

异常体系的最上层父类是Exception

Java在编译时不会运行代码

只会检查语法是否错误

或者做一些性能的优化

编译时异常核心是提醒程序员检查本地信息

运行时异常核心是代码错误导致程序出现的问题

区别

看异常时要从下往上看

作用

异常是用来查询bug的关键参考信息的

异常可以作为方法内部一种特殊的返回值，以便通知调用者底层的执行情况

调用者不知道代码执行的底层逻辑

我们可以用异常去改写，得到异常

throw关键字

抛出异常对象

则可以

JVM默认的处理异常

把异常的名称，异常的原因以及异常出现的位置等信息输出在了控制台

程序停止运行，异常下面的代码就不会再执行了

自己处理(捕获异常)

可以让程序继续往下执行，不会停止

创建异常对象

拿着这个对象到catch的小括号中去对比

看括号中的变量是否可以接受这个对象

如果能被接受，就说明该异常被捕获（抓住）

则执行catch里面的代码

当catch里面的所有代码执行完毕，继续执行try...catch体系下面的其他代码

public class Main {
    public static void main(String[] args) {
        int arr[]=new int[]{1,2,3,4,5};
        try {
            System.out.println(arr[5]);
            //可能出现异常的代码
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组越界");
            //出现异常后的处理
        }
        System.out.println("执行完毕");
    }
}

捕获异常的灵魂四问

如果try中没有遇到问题，会把try中所有的代码都执行完毕。

如果try可能遇到多个问题，会逐个捕获，写多个catch与之对应

出现异常会获得对象

从catch上往下依次进行匹配

如果我们要捕获多个异常，这些异常如果存在父与子关系的时候，那么父类一定要写在下面

在JDK 7以后，同时出现多个异常中间可以用|进行隔开,可以用一个catch同时捕获多个异常

如果try遇到的问题没有被捕获

那么相当于try...catch中的代码白写了，最终还是会交给虚拟机去进行处理

如果try遇到了问题

下面的代码就不会执行

直接跳转到对应的catch中，执行catch里面的语句体

灵魂四问小结

异常中的常见方法

printStackTrace仅仅是打印信息，不会停止虚拟机运行

最为常用

public class Main {
    public static void main(String[] args) {
        int arr[]=new int[]{1,2,3,4,5};
        try {
            System.out.println(arr[5]);
            System.out.println("未出现异常");
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            System.out.println("数组越界");
        }
        System.out.println("执行完毕");
    }
}

System.err.println("执行完毕");//打印错误信息(红色字体)

抛出处理

throws关键字

写在方法定义处，表示声明一个异常

告诉调用者，使用本方法可能有哪些异常

编译时异常，必须要写

运行时异常，可以不写

public class Main {
    public static void main(String[] args) {
        int arr[]=null;
        System.out.println(getMax(arr));
    }
    public static int getMax(int arr[]){
        int max=0;
        if(arr==null)
            //手动创建一个异常对象，并把这个异常交给方法调用者去处理
            //此时方法就会结束，下面的代码就不会再执行了
            throw new NullPointerException();
        for(int i :arr)
            if (i>max)
                max=i;
        return max;
    }

}

抛出处理小结

练习

抛出的核心思想是告诉调用者出错了

捕获的核心思想是不让程序停止

可以在JavaBean类里去改写

当找不到运行异常如何描述的时候

可以抛出运行异常的父类对象给调用者

throw new RuntimeException()

在Javabean类里抛出异常，在测试类里接受异常

如果不在测试类里处理异常，就会交给虚拟机处理，会停止程序运行

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String str) {
        //str依次表示流里面的每个数据
        //形参要和抽象方法形参一致
        String arr[]=str.split(",");
        this.name=arr[0];
        this.age=Integer.parseInt(arr[1]);
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public  String toString() {
        return  name + "-" + age ;
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Friend f=new Friend();
        while(true){
            try {
                System.out.println("请录入名称");
                String name=sc.next();
                f.setName(name);
                System.out.println("请录入年龄");
                int age=sc.nextInt();
                f.setAge(age);
                //如果捕获到了异常，会进入catch()
                //如果所有数据都正确，那么会跳出循环
                break;
            } catch (RuntimeException e) {
                System.out.println("输入的年龄不符合规范,请重新输入");
            }
        }
        System.out.println(f);
    }
}

自定义异常

根据不同的情况可以创建不同的异常对象

自己写一个异常类

定义异常类 类名要见名知意

写继承关系

空参构造

带参构造 就是为了让控制台的报错信息更加见名知意 就是为了自定义异常的名字

public class NameformatException extends RuntimeException{
    public NameformatException() {
    }

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

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Friend f=new Friend();
        while(true){
            try {
                System.out.println("请录入名称");
                String name=sc.next();
                f.setName(name);
                System.out.println("请录入年龄");
                int age=sc.nextInt();
                f.setAge(age);
                //如果捕获到了异常，会进入catch()
                //如果所有数据都正确，那么会跳出循环
                break;
            } catch (NameformatException e) {
                e.printStackTrace();
                System.out.println("输入的年龄不符合规范,请重新输入");
            }
        }
        System.out.println(f);
    }
}

public class Friend {
    private String name;
    private int age;

    public Friend() {
    }

    public Friend(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
        if(name.length()>3)
            throw new NameformatException("名称长度不符合规范");
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Friend{name = " + name + ", age = " + age + "}";
    }
}