【JAVA入门】Day36 - 异常

最新推荐文章于 2024-09-10 10:21:38 发布

Clown Piece

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量748

点赞数 17

分类专栏： JAVA入门文章标签： java 开发语言

本文链接：https://blog.csdn.net/oo00Z00oo/article/details/141998551

版权

JAVA入门专栏收录该内容

38 篇文章 1 订阅

订阅专栏

【JAVA入门】Day36 - 异常

异常就是代表程序出现的问题。Java 的异常机制可以告知 JVM，程序出现异常之后，应该如何处理。
比如下面两种异常情况：

int[] arr = {10, 20, 30};
System.out.println(arr[3]);

ArrayIndexOutOfBoundsException 数组越界异常

int a = 10;
int b = 0;
System.out.println(a / b);

ArithmeticException 算术异常

Java 中有太多异常类型了，它们组成了异常结构体系。

一、异常结构体系综述

所有的错误和异常都继承自 Java.lang.Throwable 类，然后分为两个分支，一个叫“错误”（Error），一个叫“异常”（Exception），其中异常中最重要的一个总类就是“运行时异常”（RuntimeException)，它下面还有很多很多异常类。
在这里插入图片描述

1.1 错误（Error）

Error 代表的是系统级别的错误（属于严重问题），它们是 JVM 无法解决的问题，如：栈溢出（StackOverflowError）、内存溢出（OOM）等，系统一旦出现问题，sun 公司会把这些错误封装成 Error 对象给公司内部研究，我们开发人员无需关注。

1.2 异常（Exception）

Exception 代表程序可能出现的问题，我们通常会用 Exception 及它的子类来封装程序出现的问题。

1.3 运行时异常（RuntimeException）

RuntimeException 及其子类，编译阶段不会出现异常提醒，在运行时才会出现异常（如：数组索引越界异常）。

1.4 其他异常

指的是编译阶段就会出现提醒的异常（如：日期解析异常）。

二、编译时异常和运行时异常

以下代码明确了编译时异常和运行时异常的区别：

package Exceptions;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo1 {
    public static void main(String[] args) throws ParseException {

        //编译时异常（在编译阶段，必须要手动处理，否则代码报错）
        String time = "2030年1月1日";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(time);
        System.out.println(date);

        //运行时异常（编译阶段不会出现报错，在运行时才会出现）
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(arr[10]);        //ArrayIndexOutOfBoundsException
    }
}

在这里插入图片描述

Java 为什么设计这两种异常？这正是因为 Java 在把 java 文件编译成字节码 class 文件时，不会运行代码，只会检查语法是否错误，或者做一些性能的优化。而 JVM 才是真正运行代码的。编译时异常更多地是提醒程序员检查本地信息，而运行时异常并不在于提醒，它是真的代码出错导致程序运行时出现了问题。

三、异常的作用

异常的两个重要作用就是：

作用一：异常是用来查询 bug 的关键参考信息。
作用二：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况。

3.1 查询 bug 的关键参考信息

开发环境运行代码后的异常往往会在下方提示，根据异常提示的名字、信息，我们可以快速找到 bug 产生的原因。

package Exceptions;

public class ExceptionDemo2 {
    public static void main(String[] args) {
        /*
            - 作用一：异常是用来查询 bug 的关键参考信息。
            - 作用二：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况。
         */

        Student[] arr = new Student[3];
        String name = arr[0].getName();
        System.out.println(name);

        /*
        Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Exceptions.Student.getName()" because "arr[0]" is null
	    	at Exceptions.ExceptionDemo2.main(ExceptionDemo2.java:11)
         */
    }
}

3.2 作为方法内部一种特殊的返回值

异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况。
例如下面的代码，在同学类的setAge()方法中，当年龄小于18岁或超过40岁时，抛出运行时异常。

    public void setAge(int age) {
        if(age < 18 || age > 40){
            //年龄超出范围
            throw new RuntimeException();
        } else {
            this.age = age;
        }
    }

在测试类中如果存入异常数据，会出现异常提醒。

package Exceptions;

public class ExceptionDemo3 {
    public static void main(String[] args) {
        //1.创建学生对象
        Student s1 = new Student();
        //年龄：（同学）18~40岁
        //返回异常获知赋值失败
        s1.setAge(50);

        /*
        Exception in thread "main" java.lang.RuntimeException
	at Exceptions.Student.setAge(Student.java:39)
	at Exceptions.ExceptionDemo3.main(ExceptionDemo3.java:9)
         */
    }
}

四、异常的处理方式

在 Java 中有三种异常的处理方式：
① JVM 默认的处理方式。
② 自己处理。
③ 抛出异常（交给调用者处理）。

4.1 JVM 默认的处理方式

虚拟机把异常的名称，异常原因及异常出现的位置等信息输出在控制台。
程序停止执行。

4.2 自己处理（捕获异常）

格式：

try {
	可能出现异常的代码;
} catch(异常类名 变量名) {
	异常处理的代码;
}

例子：

package Exceptions;

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

        int[] arr = {1, 2, 3, 4, 5, 6};

        try {
            System.out.println(arr[10]);
        } catch(ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }
        
        System.out.println("看看我执行了吗？");
    }
}

如果 try{ } 中的语句出现了异常，就会创建一个异常对象，创建什么对象取决于异常的类型，上面代码的异常类型是 ArrayIndexOutOfBoundsException （数组索引越界异常），然后会把这个对象和 catch() 中的异常变量进行对比，看这个变量是否可以接收这种对象，如果异常种类相同就可以接收，表示该异常被捕获，然后执行 catch() { } 中的代码，当这些代码执行完毕，会继续执行 try…catch 体系之后的其他代码，并不会导致程序的中断。

4.3 如果 try 中没有遇到问题，怎么执行？

如果 try 中没有遇到问题，会直接执行 try{ } 中的代码，而不会去执行 catch() { } 中的代码了，然后执行 try…catch 体系后面的代码。

package Exceptions;

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

        int[] arr = {1, 2, 3, 4, 5, 6};

        try {
            System.out.println(arr[0]);
        } catch(ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }

        System.out.println("看看我执行了吗？");
    }
}

4.4 如果 try 中可能会遇到多个问题，怎么执行？

如果 try{ } 中可能出现多种问题，那么我们就需要写多个 catch(){ } 与之对应。

package Exceptions;

public class ExceptionDemo6 {
    public static void main(String[] args) {
        /*
            细节：如果我们要捕获多个异常，这些异常中如果存在父子关系，那么父类一定要写在下面
         */

        int[] arr = {1, 2, 3, 4, 5, 6};

        try {
            System.out.println(arr[10]);        //ArrayIndexOutOfBoundsException
            System.out.println(2 / 0);            //ArithmeticException
            String s = null;
            System.out.println(s.equals("abc"));    //NullPointerException
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }catch(ArithmeticException e){
            System.out.println("除零错误");
        }catch(NullPointerException e){
            System.out.println("空指针异常");
        }catch(Exception e){
            System.out.println("存在异常");
        }

        //在 JDK7 以前，异常的一个捕获书写一个异常
        //如果有多个异常，处理方式是一样的，可以一起写，中间用 |
        try {
            System.out.println(2 / 0);
        }catch(ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("索引越界或除数为0");
        }
        
        System.out.println("看看我执行了吗？");
    }
}

4.5 如果 try 中碰到的问题没有被捕获？

如果 try{ } 中的代码发生的异常没有被 catch() { } 捕获到（catch 中写的异常类型和你发生的异常类型不同，所以没捕获到），虚拟机会直接报错（相当于 catch(){ } 没捕获到异常，直接交给了虚拟机处理）。

package Exceptions;

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

        int[] arr = {1, 2, 3, 4, 5, 6};

        try {
            System.out.println(arr[10]);
        } catch(NullPointerException e){
            System.out.println("索引越界了");
        }

        System.out.println("看看我执行了吗？");	//没执行

		/*
		Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 6
	at Exceptions.ExceptionDemo7.main(ExceptionDemo7.java:9)
	*/


    }
}

4.6 如果 try 中遇到了问题，那么 try 下面的其他代码还会执行吗？

try{ } 中某一行代码遇到问题，它会直接跳转到 catch() { } 结构中，并不会继续执行此行代码之后的代码。

package Exceptions;

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

        int[] arr = {1, 2, 3, 4, 5, 6};

        try{
            System.out.println(arr[10]);
            System.out.println("看看我执行了吗？... try");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }

        System.out.println("看看我执行了吗？... 其他代码");
    }
}

五、Throwable 类

Throwable 类是异常的最高层类，它有三个常用方法。

在这里插入图片描述
三个方法的使用特征如下：

package Exceptions;

public class ExceptionDemo9 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};

        try {
            System.out.println(arr[10]);
        } catch (ArrayIndexOutOfBoundsException e) {
            String message = e.getMessage();
            System.out.println(message);            //Index 10 out of bounds for length 6

            String str = e.toString();
            System.out.println(str);                //java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 6

            e.printStackTrace();                    //java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 6
                                                    //      at Exceptions.ExceptionDemo9.main(ExceptionDemo9.java:8)
            //printStackTrace方法会把异常信息以红色字体打印在虚拟机控制台
            //但是这样做不会结束代码的执行，后面的代码仍旧可以执行
        }

        System.out.println("看看我执行了吗");
    }
}

printStackTrace() 方法所包含的信息已经包含了前两个方法的信息，我们在使用时一般都使用这个方法，且这个方法是 try…catch 结构的默认处理方法。
这个方法在底层是利用 System.err.println() 方法进行输出，因此可以把字体转为红色打印在控制台。

六、抛出处理

throws 和 throw 的区别：

throws：写在方法定义处，表示声明一个异常，告诉调用者，使用本方法可能会有哪些异常。

public void 方法() throws 异常类名1,异常类名2... {
	...
}

注意：如果异常是编译时异常，那就必须要写；如果是运行时异常，可以不写。

throw：写在方法内部，手动抛出异常对象，交给调用者，方法中下面的代码就不再执行了。

public void 方法(){
	throw new NullPointerException();
}

异常抛出的用例：

package Exceptions;

public class ExceptionDemo10 {
    public static void main(String[] args) {
        /*
           调用方法求一个数组的最大值
         */
        int[] arr = null;
        try {
            int max = getMax(arr);
        } catch (NullPointerException e) {
            System.err.println("空指针异常");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("索引越界异常");
        }


    }

    public static int getMax(int[] arr){
        if(arr == null) {
            throw new NullPointerException();       //手动创建一个异常对象，并把这个异常交给方法调用者处理
            //之后的代码就不会再执行
        }

        if(arr.length == 0) {
            throw new ArrayIndexOutOfBoundsException();
        }

        System.out.println("看看我执行了吗？");
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

【练习】使用异常完成需求。
需求:
        键盘录入自己心仪的女朋友姓名和年龄。姓名的长度在3~10之间，
        年龄的范围为18– 40岁，
        超出这个范围是异常数据不能赋值，需要重新录入,一直录到正确为止。
提示:
        需要考虑用户在键盘录入时的所有情况。
        比如:录入年龄时超出范围，录入年龄时录入了abc等情况。

package Exceptions;

import java.util.Scanner;

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

        /*
              姓名长度为 3-10
              年龄范围为 18-40
              否则不赋值，重新录入
              改写set方法
         */


        //1.键盘录入
        Scanner sc = new Scanner(System.in);

        //2.女朋友对象
        GirlFriend gf = new GirlFriend();


        while (true) {
            //3.接收女朋友的姓名

            try {
                System.out.println("请输入女朋友名字:");
                String name = sc.nextLine();
                gf.setName(name);

                //4.接收女朋友的年龄
                System.out.println("请输入女朋友的年龄:");
                String ageStr = sc.nextLine();
                int age = Integer.parseInt(ageStr);
                gf.setAge(age);

                //如果所有的输入数据都是正确的，跳出循环
                break;

            } catch (NumberFormatException e) {
                System.out.println("年龄的格式有误，请输入数字。");

            } catch (RuntimeException e) {                          //父类一定要写在下面
                System.out.println("姓名的长度或年龄的范围有误。");
            }

        }

        //5.打印
        System.out.println(gf.toString());
    }
}

要注意，这里的抛出异常，需要自己设定，在 GirlFriend 类中写具体的抛出语句，因为 Java 不会知道你对姓名和年龄的特殊要求，这里的异常需要手动抛出。

    public void setName(String name) {
        int len = name.length();
        if(len < 3 || len > 10){
            throw new RuntimeException();
        }
        this.name = name;
    }

    public void setAge(int age) {
        if(age < 18 || age > 40){
            throw new RuntimeException();
        }
        this.age = age;
    }

七、自定义异常

通过上面的例子我们意识到，Java 给我们准备的异常不能满足我们平时的需求，需要我们自定义想要的异常类型。定义一个异常类的目的，就是为了让控制台的报错信息更加见名知意。
定义一个完整的异常类，我么要按照以下步骤：
① 定义异常类
② 写继承关系
③ 空参构造
④ 带参构造

将上面的方法改为抛出自定义异常，可以分别告知“姓名”和“年龄”的异常，并且可以直接传递异常信息作为参数。
先定义一个姓名格式异常，继承运行时异常。注意见名知意，然后带一个空参构造，一个有参构造，参数是错误信息。

package Exceptions;

public class NameFormatException extends RuntimeException {
    //NameFormat:当前异常名字，表示姓名格式化问题
    //Exception:当前类是一个异常类

    //运行时：继承RuntimeException
    //编译时：继承Exception


    public NameFormatException() {
    }

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

再定义一个年龄超范围异常。

package Exceptions;

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

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

改造 GirlFriend 类代码，抛出这两个异常，可以加提示信息作为参数。

    public void setName(String name) {
        int len = name.length();
        if(len < 3 || len > 10){
            throw new NameFormatException(name + "格式有误，长度应该为：3~10");
        }
        this.name = name;
    }

    public void setAge(int age) {
        if(age < 18 || age > 40){
            throw new AgeOutOfBoundsException(age + "年龄超出了范围");
        }
        this.age = age;
    }

在测试类中捕获异常，可以分别捕获，分别处理，可用 printStackTrace() 方法直接打印异常信息。

package Exceptions;

import java.util.Scanner;

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

        /*
              姓名长度为 3-10
              年龄范围为 18-40
              否则不赋值，重新录入
              改写set方法
         */


        //1.键盘录入
        Scanner sc = new Scanner(System.in);

        //2.女朋友对象
        GirlFriend gf = new GirlFriend();


        while (true) {
            //3.接收女朋友的姓名

            try {
                System.out.println("请输入女朋友名字:");
                String name = sc.nextLine();
                gf.setName(name);

                //4.接收女朋友的年龄
                System.out.println("请输入女朋友的年龄:");
                String ageStr = sc.nextLine();
                int age = Integer.parseInt(ageStr);
                gf.setAge(age);

                //如果所有的输入数据都是正确的，跳出循环
                break;

            } catch (NumberFormatException e) {
                System.out.println("年龄的格式有误，请输入数字。");

            } catch (NameFormatException e) {                          //父类一定要写在下面
                e.printStackTrace();

            } catch (AgeOutOfBoundsException e) {
                e.printStackTrace();
            }

        }

        //5.打印
        System.out.println(gf.toString());
    }
}

Clown Piece

关注

17
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
【JAVA入门】Day36 - 异常

通过上面的例子我们意识到，Java 给我们准备的异常不能满足我们平时的需求，需要我们自定义想要的异常类型。定义一个异常类的目的，就是为了让控制台的报错信息更加见名知意。定义一个完整的异常类，我么要按照以下步骤：① 定义异常类② 写继承关系③ 空参构造④ 带参构造将上面的方法改为抛出自定义异常，可以分别告知“姓名”和“年龄”的异常，并且可以直接传递异常信息作为参数。先定义一个姓名格式异常，继承运行时异常。注意见名知意，然后带一个空参构造，一个有参构造，参数是错误信息。
复制链接

扫一扫