30. 异常

已于 2024-02-18 17:06:56 修改
阅读量978 收藏 17
点赞数 19
分类专栏： Java基础语法 文章标签： linux 开发语言 java
于 2024-02-14 18:31:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuxiaoyang/article/details/136114597
版权

异常

文章中的部分照片来源于哔站黑马程序员阿伟老师处，仅用学习，无商用，侵权联系删除！

IO流异常 详细

具体异常信息请查看 API 帮助文档

1. 概述

在Java中，错误（Error）类和异常（Exception）类都是继承自Throwable类，用于表示程序中出现的问题或异常情况。
在这里插入图片描述

  • 错误类（Error）：错误类表示严重的问题，通常是由虚拟机内部错误或系统资源耗尽等问题引起的。这些错误类通常是无法恢复的，程序无法处理，也没有必要进行捕获和处理。

    • 需要注意的是，错误类通常由虚拟机自动抛出，而不需要代码中显式地进行捕获和处理。

  • 异常类（Exception）：异常类用于表示程序中的正常但意外的情况。与错误类不同，异常类分为两类：编译异常和运行异常。

    • 编译异常（Checked Exception）：编译异常指在编译阶段就需要处理的异常，编译器会强制要求程序员在代码中显式地捕获和处理这些异常。

      • 处理编译异常的方式可以是使用try-catch块捕获和处理异常，或者在方法中使用throws关键字声明可能抛出的受检异常。

    • 运行异常（Unchecked Exception）：运行异常是在程序执行过程中发生的异常，不需要在代码中显式地捕获和处理。它们通常由代码中的错误或逻辑问题引起，如空指针异常（NullPointerException）或数组索引越界异常（ArrayIndexOutOfBoundsException）等。

      • 运行异常通常表示程序的逻辑错误或程序员的错误。
      • 处理运行异常的方式是可选择性地进行捕获和处理，也可以让程序崩溃并终止运行。

    • 需要注意的是，RuntimeException及其子类是Java中常见的运行异常类。

除了预定义的错误类和异常类，Java还允许使用者自定义异常类。通过继承Exception类或其子类来创建自定义异常类，以更好地描述和处理特定的异常情况。

2. Throwable 方法

2.1 概述

  • Throwable 是 Java 中所有错误和异常的根类。它定义了处理错误和异常的基本方法和属性。

  • 需要注意的是，Throwable 是一个抽象类，不能直接实例化。

  • 它有两个直接子类：Error 和 Exception。

    • Error 类表示严重的错误，通常无法恢复；

    • Exception 类表示可处理的异常情况。

    • 开发者也可以继承 Throwable 类创建自定义的错误或异常类。

  • Throwable的成员方法：

    方法名称说明
    public string getMessage()返回此 throwable 的详细消息字符串
    public string toString()返回此可抛出的简短描述
    public void printStackTrace()用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机）

  • 正确的输出语句：System.out.println();

  • 错误的输出语句：（不是代码错误，而是用来打印错误信息的）System.err.println();

     细节：当正确的输出语句和错误的输出语句同时使用时，两者的输出顺序不确定。

2.2 代码示例

  • 代码示例
    package text.text02;

/*
Throwable的成员方法：

| 方法名称                      | 说明                                                         |
| ----------------------------- | ------------------------------------------------------------ |
| public string getMessage()    | 返回此 throwable 的详细消息字符串                            |
| public string tostring()      | 返回此可抛出的简短描述                                       |
| public void printstackTrace() | 用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机） |

正确的输出语句：System.out.println();
错误的输出语句：（不是代码错误，而是用来打印错误信息的）System.err.println();
    细节：当正确的输出语句和错误的输出语句同时使用时，两者的输出顺序不确定。
 */
public class text88 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};

        //1.public string getMessage(): 返回此 throwable 的详细消息字符串
        System.out.println("=============== 1.public string getMessage(): 返回此 throwable 的详细消息字符串 ===============");

        //自己处理（捕获异常）
        try {
            System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            String message = e.getMessage();
            System.out.println(message);
        }
        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");


        //2.public string tostring(): 返回此可抛出的简短描述
        System.out.println("=============== 2.public string tostring(): 返回此可抛出的简短描述 ===============");

        //自己处理（捕获异常）
        try {
            System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            String str = e.toString();
            System.out.println(str);
        }
        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");


        //3.public void printstackTrace(): 用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机）
        System.out.println("=============== 3.public void printstackTrace(): 用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机） ===============");

        //自己处理（捕获异常）
        try {
            System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");
    }
}
  • 输出结果
    在这里插入图片描述

3. 异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常

  • 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)

  • 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

​ 在这里插入图片描述

4. 异常处理方式

4.1 JVM默认处理异常

JVM（Java虚拟机）具有默认的异常处理机制，用于处理在程序执行期间可能抛出的未捕获异常。

  • JVM默认处理异常的方式：

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

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

需要注意的是，JVM的默认异常处理机制只能处理未捕获的异常。对于已经在代码中进行了捕获并做了处理的异常，JVM不会介入其中。

  • 代码示例
    package text.text02;

/*
JVM默认处理异常的方式：
    1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
    2.程序停止执行，异常下面的代码就不会再执行
 */
public class text82 {
    public static void main(String[] args) {

        System.out.println("aaaaa");
        System.out.println("bbbbb");

        //算术异常(ArithmeticException)
        System.out.println(10 / 0);

        System.out.println("ccccc");
        System.out.println("ddddd");

    }
}
  • 输出结果
    在这里插入图片描述

4.2 自己处理（捕获异常）try...catch

IO流异常 详细

4.2.1 概述

  • 目的：当代码出现异常时，可以让程序继续往下执行。

  • 在Java中，可以使用try...catch语句块来捕获和处理异常。

  • try...catch语句块的基本语法如下：

    try {
    // 可能会抛出异常的代码
} catch (异常类型1 异常变量1) {
    // 处理异常类型1的代码
} catch (异常类型2 异常变量2) {
    // 处理异常类型2的代码
} finally {
    // 可选的finally代码块，无论是否发生异常，都会被执行
}

try代码块包含了可能会抛出异常的代码。当异常发生时，Java虚拟机会立即停止当前代码块的执行，并跳转到catch代码块中，根据异常的类型与catch代码块中的异常类型进行匹配。

  • 如果匹配成功，则执行对应的catch代码块，进行异常处理。

  • 如果没有匹配的catch代码块，则异常将被传递到更高层的调用栈中，继续寻找匹配的catch代码块。

  • 如果找不到任何匹配的catch代码块，程序将会终止，并输出相关的异常信息。

catch代码块用于处理特定类型的异常。你可以在一个try结构中使用多个catch代码块，以处理不同类型的异常。每个catch代码块包含了异常类型和异常变量，异常变量用于引用被捕获的异常对象，以便进行进一步的处理。

finally代码块是可选的，用于定义无论是否发生异常，都会执行的代码。它一般被用于释放资源或进行清理操作。即使在try或catch代码块中有return语句，finally代码块仍然会在return之前执行。

  • 代码示例
    package text.text02;

/*自己处理（捕获异常）
格式：
    try {
        可能出现的异常;
    } catch (异常类名 变量名){
        异常的处理代码;
    }

目的：当代码出现异常时，可以让程序继续往下执行。

 自己处理（捕获异常）灵魂四问：
    1.一问：如果try中没有遇见问题，怎么执行？
        答：如果try中没有遇见问题，会吧try里面的代码全部执行完毕，再继续执行try...catch体系下面的其他代码，而不会执行catch里面的代码
        注意：只有当出现了异常才会执行catch里面的代码。

    2.二问：如果try中可能遇见多个问题，怎么执行？
        答：如果try中可能遇见多个问题，一般需要写多个catch与之对应。
         try中代码会从上往下执行，如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

        细节：如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面

        JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案

    3.三问：如果try中遇见的问题没有被捕获，怎么执行？
        答：如果try中遇见的问题没有被捕获,相当于try...catch体系白写了，Java会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

    4.四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？
        答：如果try中遇见了问题，那么try下面的其他代码不会执行了，会直接跳转到catch当中，执行catch里面的代码。如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

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

        //自己处理（捕获异常）
        try {
            System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException
            //此处出现了异常，程序就会在这里创建一个ArrayIndexOutOfBoundsException（索引越界异常）对象（new ArrayIndexOutOfBoundsException()）；拿着这个对象到catch的小括号中对比，看括号中的变量是否可以接受这个对象。如果可以被接受，就表示该异常被捕获（抓住），执行catch里面对应的代码。当catch里面的所有的代码都执行完毕，继续执行try...catch体系下面的其他代码

            //异常类名: ArrayIndexOutOfBoundsException
            //变量名: e
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界异常!" + e);
        }

        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");
    }
}
  • 输出结果
    在这里插入图片描述
4.2.2 灵魂四问

自己处理（捕获异常）灵魂四问：

  1. 一问：如果try中没有遇见问题，怎么执行？

    • 答：如果try中没有遇见问题，会吧try里面的代码全部执行完毕，再继续执行try…catch体系下面的其他代码，而不会执行catch里面的代码

    • 注意：只有当出现了异常才会执行catch里面的代码。

  2. 二问：如果try中可能遇见多个问题，怎么执行？

    • 答：如果try中可能遇见多个问题，一般需要写多个catch与之对应。

    • try中代码会从上往下执行，如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

    • 细节：如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面

    • JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案

  3. 三问：如果try中遇见的问题没有被捕获，怎么执行？

    • 答：如果try中遇见的问题没有被捕获,相当于try…catch体系白写了，Java会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

  4. 四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？

    • 答：如果try中遇见了问题，那么try下面的其他代码不会执行了，会直接跳转到catch当中，执行catch里面的代码。如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

  • 代码示例1：一问：如果try中没有遇见问题，怎么执行？

    package text.text02;

/*
 自己处理（捕获异常）灵魂四问：
    一问：如果try中没有遇见问题，怎么执行？
      答：如果try中没有遇见问题，会吧try里面的代码全部执行完毕，再继续执行try...catch体系下面的其他代码，而不会执行catch里面的代码
        注意：只有当出现了异常才会执行catch里面的代码。
 */
public class text84 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};

        //自己处理（捕获异常）
        try {
            System.out.println(arr[0]);
            System.out.println("try里面的代码执行了");

            //异常类名: ArrayIndexOutOfBoundsException
            //变量名: e
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界异常!" + e);
        }

        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");
    }
}

  • 输出结果1
    在这里插入图片描述

  • 代码示例2：二问：如果try中可能遇见多个问题，怎么执行？

    package text.text02;

/*
 自己处理（捕获异常）灵魂四问：
 二问：如果try中可能遇见多个问题，怎么执行？
      答：如果try中可能遇见多个问题，一般需要写多个catch与之对应。
         try中代码会从上往下执行，如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

      细节：如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面

      JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案
 */
public class text85 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};

        //JDK7以前
        System.out.println("JDK7以前：");
        //自己处理（捕获异常）
        try {
            System.out.println(10 / 0);//算术异常 ArithmeticException
            System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException

            String str = null;
            System.out.println(str.equals("aaa"));//空指针异常 NullPointerException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界异常!" + e);
        } catch (ArithmeticException e) {
            System.out.println("算术异常!" + e);
        } catch (NullPointerException e) {
            System.out.println("空指针异常!" + e);
        }
        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");


        //JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案
        System.out.println("JDK7以后：");
        try {
            System.out.println(10 / 0);//算术异常 ArithmeticException
            System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException

            String str = null;
            System.out.println(str.equals("aaa"));//空指针异常 NullPointerException
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException | NullPointerException e) {
            System.out.println("出现异常!" + e);
        }
        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");
    }
}

  • 输出结果2
    在这里插入图片描述

  • 代码示例3：三问：如果try中遇见的问题没有被捕获，怎么执行？

    package text.text02;

/*
 自己处理（捕获异常）灵魂四问：
  三问：如果try中遇见的问题没有被捕获，怎么执行？
    答：如果try中遇见的问题没有被捕获,相当于try...catch体系白写了，Java会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）
 */
public class text86 {
    public static void main(String[] args) {

        //自己处理（捕获异常）
        try {
            System.out.println(10 / 0);//算术异常 ArithmeticException

        } catch (ArrayIndexOutOfBoundsException e) { //索引越界异常  ArrayIndexOutOfBoundsException
            System.out.println("索引越界异常!" + e);
        }

        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");
    }
}

  • 输出结果3
    在这里插入图片描述

  • 代码示例4：四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？

    package text.text02;

/*
自己处理（捕获异常）灵魂四问：
四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？
  答：如果try中遇见了问题，那么try下面的其他代码不会执行了，会直接跳转到catch当中，执行catch里面的代码。如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）
*/
public class text87 {
    public static void main(String[] args) {
        //自己处理（捕获异常）
        try {
            System.out.println(10 / 0);//算术异常 ArithmeticException
            System.out.println("try里面的代码执行了");
        } catch (ArithmeticException e) {
            System.out.println("算术异常!" + e);
        }
        //检验代码是否执行到这一步
        System.out.println("try...catch体系外的代码执行了");
    }
}

  • 输出结果4
    在这里插入图片描述

4.3 抛出处理(throw和throws)

在Java中，throw和throws是用于异常处理的关键字，用于处理和传递异常。

  1. throw关键字：

    • 使用throw关键字可以手动抛出一个异常。你可以将任何继承自Throwable类的异常对象抛出。

    • throw语句通常放在条件语句或代码块中，用于在特定情况下抛出异常。

    • 抛出异常将程序的控制权交给上层调用栈，直到找到合适的异常处理器来处理异常。

    • 使用throw抛出的异常可以是受检查异常也可以是非受检查异常。

  • throw:写在方法内，结束方法，手动抛出异常对象，交给调用者，方法下面的代码不再执行了

    • 格式：
    throw new 异常类名(参数);
    • 举例：
    throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
  1. throws关键字：
    • throws关键字用于声明一个方法可能抛出的异常类型。
    • 在方法声明中，可以使用throws关键字后跟一个异常类型或异常类型的列表，多个异常类型之间用逗号分隔。
    • 声明throws的作用是告知调用者方法可能抛出的异常，以让调用者知道需要进行相应的异常处理或继续将异常传递给上层代码。
    • 如果一个方法声明了抛出异常，而调用者没有进行处理或继续传递，那么调用者也必须使用throws关键字声明进行处理。

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

    • 格式：
    修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }
    • 举例：
    public void 方法() throws 异常类名1,异常类名2...{
	 ...
 }

      · 编译时异常：必须手写
  · 运行时异常：可以省略

  • 代码示例
    练习：定义一个方法求数组的最大值

    package text.text02;

/*抛出处理：
throws: 写在方法定义处，表示声明一个异常，告诉调用者，使用本方法可能会有哪些异常
    格式：修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }
    举例：public void 方法() throws 异常类名1,异常类名2...{
             ...
         }
    · 编译时异常：必须手写
    · 运行时异常：可以省略

throw:写在方法内，结束方法，手动抛出异常对象，交给调用者，方法下面的代码不再执行了
    格式：throw new 异常类名(参数);
    举例：throw new NullPointerException("要访问的arr数组不存在");
         throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

练习：定义一个方法求数组的最大值
 */
public class text89 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 56, 7, 8, 9, 10, 5, 6};
        int[] arr1 = null;
        int[] arr2 = {};

        int max = 0;
        int max1 = 0;
        int max2 = 0;

        //捕获异常
        try {
            max = getMax(arr);
            max1 = getMax(arr1);
            max2 = getMax(arr2);
        } catch (NullPointerException | IndexOutOfBoundsException e) {
            e.printStackTrace();
        }

        System.out.println(max);
        System.out.println(max1);
        System.out.println(max2);
    }

    public static int getMax(int[] arr) /* throws NullPointerException,IndexOutOfBoundsException*/ { //运行时异常：可以省略
        if (arr == null) {
            //手动创建一个异常对象，并把这个异常交给方法的调用者处理，此时方法就会结束，下面的代码不会再执行了
            throw new NullPointerException();//空指针异常  NullPointerException
        }
        if (arr.length == 0) {
            //手动创建一个异常对象，并把这个异常交给方法的调用者处理，此时方法就会结束，下面的代码不会再执行了
            throw new IndexOutOfBoundsException();//索引越界异常  IndexOutOfBoundsException
        }
        int max = arr[0];
        for (int i : arr) {
            if (i > max) {
                max = i;
            }
        }
        return max;
    }
}

  • 输出结果
    在这里插入图片描述

5. 自定义异常

5.1 概述

在Java中，可以通过自定义异常来创建特定的异常类型，以便更好地处理和标识特定的异常情况。

自定义异常允许定义具有特定行为和属性的异常类，用于在程序中抛出和捕获异常。

  • 目的：为了让控制台的报错信息更加的见名之意

  • 步骤：

    1. 定义异常类

    2. 写继承关系

    3. 空参构造

    4. 带参构造

5.2 代码示例

  • 代码示例

    • 练习：键盘录入数据：

    • 需求：

      • 1.键盘录入自己心仪的女朋友姓名和年龄，

      • 2.姓名的长度在3-10之间，

      • 3.年龄的范围为 18-40岁

      • 4.超出这个范围是异常数据不能赋值，需要重新录入,一直录到正确为止。

    • 提示: 需要考虑用户在键盘录入时的所有情况。

      • 比如:录入年龄时超出范围，录入年龄时录入了abc等情况
      package text.text02;

import java.util.Scanner;

/*
自定义异常：
目的：为了让控制台的报错信息更加的见名之意

步骤：1.定义异常类
     2.写继承关系
     3.空参构造
     4.带参构造


练习：
    键盘录入数据：
    需求：1.键盘录入自己心仪的女朋友姓名和年龄，
         2.姓名的长度在3-10之间，
         3.年龄的范围为 18-40岁
         4.超出这个范围是异常数据不能赋值，需要重新录入,一直录到正确为止。
    提示:
        需要考虑用户在键盘录入时的所有情况。
        比如:录入年龄时超出范围，录入年龄时录入了abc等情况
 */
public class text91 {
    public static void main(String[] args) {
        //空参创建学生对象
        girlFriend1 gf = new girlFriend1();
        //键盘录入
        Scanner sc = new Scanner(System.in);
        while (true) {
            //捕获异常
            try {
                System.out.println("请输入姓名：");
                String name = sc.nextLine();
                gf.setName(name);
                System.out.println("请输入年龄：");
                String ageString = sc.nextLine();
                int age = Integer.parseInt(ageString);
                gf.setAge(age);
                //如果所有的数据都是正确的，跳出循环
                break;
            } catch (NumberFormatException e) {
                System.out.println("年龄的格式有误，请输入数字！");
                e.printStackTrace();
            } catch (nameFormatException e) {
                e.printStackTrace();
            } catch (ageOutOfBoundsException e) {
                e.printStackTrace();
            }
        }

        System.out.println(gf.getName() + " , " + gf.getAge());

    }
}

//自定义姓名格式化异常
class nameFormatException extends RuntimeException {
    public nameFormatException() {
    }

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

//自定义年龄格式化异常
class ageOutOfBoundsException extends RuntimeException {
    public ageOutOfBoundsException() {
    }

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


class girlFriend1 {
    private String name;
    private int age;

    public girlFriend1() {
    }

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

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

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        if (name.length() < 3 || name.length() > 10) {
            throw new nameFormatException("姓名的长度有误！");
        } else {
            this.name = name;
        }
    }

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

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        if (age < 18 || age > 40) {
            throw new ageOutOfBoundsException("年龄的范围有误！");
        } else {
            this.age = age;
        }
    }

    public String toString() {
        return "girlFriend{name = " + name + ", age = " + age + "}";
    }
}
  • 输出结果
    在这里插入图片描述

6. 异常注意事项

  1. 运行时异常被抛出可以不处理。即不捕获也不声明抛出。

  2. 如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。

  3. 父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

  4. 当多异常处理时，捕获处理，前边的类不能是后边类的父类

  5. 在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。

酷小洋
关注
专栏目录
java.util.concurrent.RejectedExecutionException异常
悟已往之不谏，知来者之可追
01-18 2万+
场景 业务一切正常，突然收到一堆告警，发现全是 java.util.concurrent.RejectedExecutionException异常报错。 具体看了下代码，里面的执行逻辑也不难，没有外部依赖都是内存多线程cpu类型计算的逻辑。 下面是报错的线程池状态变化，由上到下，按照时间增长，最后达到饱和。 java.util.concurrent.ThreadPoolExecutor@57b5ea0f[Running, pool size = 99, active threads = 75, queued
java.sql.SQLException异常
chuzhong1074的博客
07-12 2893
新版数据库驱动连接异常 java.sql.SQLException: The server time zone value 'EDT' is unrecognized or represents more than one time zone. You must configure eith...
19.异常处理
qq_40407729的博客
02-01 4528
异常指程序在运行时发生的错误。如果没有提前对错误设置处理，程序将自动停止。 异常处理主要指的是对异常的捕获、处理及引发异常。 一、异常的类型 异常在python中是一种对象，对应不同原因引起的错误有不同的错误类型。 ...
Javase.认识异常
Joseit的博客
06-21 2309
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
dubbo实践1..异常处理
闲来觅箫声
04-26 1万+
使用dubbo有几年了，最近开始在博客上分享自己的一些实际工作经验，今天就先说下dubbo的异常处理，请大家多加指正。           dubbo有自己的异常处理机制，当服务端抛出一个dubbo可以处理传递的异常时，会直接在客户端上再次抛出，由开发者自己去处理。注意：这里说的不是所有异常，而是dubbo可以处理传递的异常，具体这个后边再说。      先看两段代码，接口代码：
java.lang.NoSuchFieldError异常
qq_37966029的博客
07-10 2647
java.lang.NoSuchFieldError异常 今天碰到这个异常，搞了大半天，头大，一步一步排查，原因是因为我把swing的项目整合到javaFX相关的项目中，两个项目都用到了很多第三方jar包，还有自己写的jar包，最终通过测试，找出来是其中一个jar包冲突，版本不一致导致的，删除低版本的，从新编译，问题解决。 ...
Springboot2.x 全局异常+日志
西伯利亚疯狂的蚯蚓
05-29 2477
前言 本文是蚯蚓在自己搭建一个通用的springboot后台管理系统框架，且边学习springboot边做的，若有不足之处，希望大家不吝留言，非常感谢。 架构要求： 1.使用全局异常处理，即控制层、业务层、持久层等分层中的方法均不使用try……catch对异常进行捕获处理，所有异常抛出，最终在请求结束后，统一处理。 2.日志需要记录完整的一次请求，包括请求参数：url、请求方式（如get、...
CompletableFuture CompletableFuture.supplyAsync 异常处理
热门推荐
weixin_30613343的博客
01-30 1万+
CompletableFuture 异常处理completeExceptionally可以把异常抛到主线程 /** * User: laizhenwei * Date: 2018-01-30 Time: 22:26 * Description: */ @RunWith(SpringRunner.class) //@SpringBootTest public class ...
redis Unexpected end of stream. 异常
yuhui666666的博客
05-12 4737
近期生产环境碰到不少redis的异常，有获取不到连接的，有返回资源出错，还有就是Unexpected end of stream. 这个异常。各种百度google之后发现造成这种问题的原因大致如下 1.输出缓冲区满。例如将普通客户端的输出缓冲区设置为1M 1M 60： config set client-output-buffer-limit "normal 1048576 1048576 60 slave 268435456 67108864 60 pubsub 33554432 8388608 60
已解决org.springframework.web.HttpSessionRequiredException异常的正确解决方法，亲测有效！！！
小明的Java问道之路
02-23 2706
已解决org.springframework.web.HttpSessionRequiredException异常的正确解决方法，亲测有效！！！
Access_JDBC30.jar【破解版】
04-04
1.破解仅支持连续查询50次和1000行的限制； 2.修复原版jar包使用execute()和executeUpdate()方法报空指针异常的BUG。
Python使用sys.exc_info()方法获取异常信息
09-16
### Python使用`sys.exc_info()`方法获取异常信息 在Python编程过程中，正确处理异常是非常重要的。这不仅能提高程序的健壮性，还能帮助开发者更好地理解并解决遇到的问题。`sys.exc_info()`方法是Python中用于获取...
Python 异常机制 第九章 异常和错误.pdf
02-09
Python 异常机制 Python 的异常机制是指在程序执行过程中出现的非正常现象，例如用户输入错误、除数...正常情况，自己遵循如上步骤解决 30 个以上的错误，就能积累初步的调试经验，以后遇到的大部分错误都能独立完成。
【Linux】进程状态相关知识详细梳理
fulufulucode的博客
11-03 738
可以看到，子进程退出后，父进程没有进行资源回收（调用wait()）,子进程的状态就会变成“Z+”，其中Z表示僵尸状态 ，+表示进程属于前台进程的一部分。每个僵尸进程在进程表中保留一个条目，系统的进程表是有限的。如果僵尸进程数量过多，可能会导致进程表满，新的进程无法创建。fork函数“有两个返回值”，父进程会返回子进程的pid，子进程会返回0，于此同时，子进程会继承父进程的代码以及数据（所有运行在系统里的进程都以task_struct链表的形式存在内核里，也可以称为进程表。那么如果父进程先退出呢？
Linux下的systemd/service
zxz_Fine的博客
11-05 522
开机自启任务
Linux/Unix echo命令
Oo_Amy_oO的博客
11-04 991
echo是 Linux 和 Unix 系统中一个非常基本且常用的命令行工具，用于在终端或文件中显示文本。以下是一些echo在终端显示 “Hello, World!echo $PATH显示环境变量PATH的值。将 “New content” 写入file.txt，如果文件不存在则创建它。将 “Additional content” 追加到file.txt文件的末尾。使用-e选项来解释转义序列（如\n表示换行）。使用-n选项来防止echo命令在输出后添加换行符。echo $?显示上一个命令的退出状态。$(
linux-find和zgrep
最新发布
luxideyao的专栏
11-07 227
命令本身并不支持递归搜索，它只能搜索单个压缩文件。但是，你可以结合使用。如果你想要搜索所有类型的压缩文件，你可以使用。是你想要搜索的目录的路径。是你想要搜索的文本模式，文件，你可能需要使用。文件并搜索其中的内容。作为输入文件的占位符。
Linux：网络协议socket
Au_ust的博客
11-05 1052
我们之前学的通信是本地进程间通信，如果我们想在网络间通信的话，就需要用到二者的ip地址，分别被称为源IP地址和目的IP地址，被存入ip数据包中，其次我们还需要遵循一些通信协议。TCP协议：传输层协议，有连接，可靠传输，面向字节流（无明确边界的字节序列），难UDP协议：传输层协议，无连接，不可靠传输，面向数据流（以数据包为单位），简单网络通信的本质也是进程间通信，你怎么知道你要和哪个进程通信？
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 865
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
不要遍历清除，foreach (var item in comboBox30.Items) { comboBox30.Items.Remove(item); }
09-14
这段代码试图在遍历`comboBox30.Items`集合的同时移除元素，这可能会导致异常或者移除操作没有效果，因为移除元素后集合的索引发生了变化，但foreach循环的迭代器并不知道这些变化。 为了解决这个问题，可以采用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

酷小洋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值