30. 异常

已于 2024-02-18 17:06:56 修改
阅读量912 收藏 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代码块，其中的代码一定会被执行，通常用于资源回收。

酷小洋
关注
  • 19
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
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
【SpringBoot】29、SpringBoot中定制异常页面
热门推荐
Asurplus
08-07 20万+
定制异常页面，可以避免用户产生恐慌心理，使得产品有更好的用户体验。今天来学习在 SpringBoot 中如何定制开发异常页面 一、历史回顾 在 SpringMVC 年代，我们的异常页面一般配置在 web.xml 文件中，如下： <!-- 配置404页面 --> <error-page> <error-code>404</error-code> <location>/error/404.html</location>
19.异常处理
qq_40407729的博客
02-01 4311
异常指程序在运行时发生的错误。如果没有提前对错误设置处理，程序将自动停止。 异常处理主要指的是对异常的捕获、处理及引发异常。 一、异常的类型 异常在python中是一种对象，对应不同原因引起的错误有不同的错误类型。 ...
dubbo实践1..异常处理
闲来觅箫声
04-26 1万+
使用dubbo有几年了，最近开始在博客上分享自己的一些实际工作经验，今天就先说下dubbo的异常处理，请大家多加指正。           dubbo有自己的异常处理机制，当服务端抛出一个dubbo可以处理传递的异常时，会直接在客户端上再次抛出，由开发者自己去处理。注意：这里说的不是所有异常，而是dubbo可以处理传递的异常，具体这个后边再说。      先看两段代码，接口代码：
java.lang.NoSuchFieldError异常
qq_37966029的博客
07-10 2594
java.lang.NoSuchFieldError异常 今天碰到这个异常，搞了大半天，头大，一步一步排查，原因是因为我把swing的项目整合到javaFX相关的项目中，两个项目都用到了很多第三方jar包，还有自己写的jar包，最终通过测试，找出来是其中一个jar包冲突，版本不一致导致的，删除低版本的，从新编译，问题解决。 ...
java.sql.SQLException异常
chuzhong1074的博客
07-12 2858
新版数据库驱动连接异常 java.sql.SQLException: The server time zone value 'EDT' is unrecognized or represents more than one time zone. You must configure eith...
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 ...
【已解决】java.io.FileNotFoundException 异常
宜春
09-27 3万+
其实出现该异常一般有两种原因： 1、系统找不到指定的文件。 2、拒绝访问。 针对第一种情况解决方法 pot.txt 应该存在于工程目录下，而不是工程的子目录(生成的文件也在工程目录下.),报错的原因也很简单，不是你的文件不存在就是放错位置了，没有放到工程目录下~ 针对第二种情况解决方法 该异常主要由于IO流针对文件而言，没有权限访问文件目录，FileOutputStream读取流的时候如...
Springboot项目全局异常统一处理
hao_kkkkk的专栏
06-01 11万+
最近在做项目时需要对异常进行全局统一处理，主要是一些分类入库以及记录日志等，因为项目是基于Springboot的，所以去网络上找了一些博客文档，然后再结合项目本身的一些特殊需求做了些许改造，现在记录下来便于以后查看。 在网络上找到关于Springboot全局异常统一处理的文档博客主要是两种方案： 1、基于@ControllerAdvice注解的Controller层的全局异常统一处理 以下是...
redis Unexpected end of stream. 异常
yuhui666666的博客
05-12 4454
近期生产环境碰到不少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
Access_JDBC30.jar
06-02
Access_JDBC30.jar解决 1.破解仅支持连续查询50次和1000行的限制； 2.修复原版jar包使用execute()和executeUpdate()方法报空指针异常的BUG。
Access_JDBC30.jar【破解版】
04-04
1.破解仅支持连续查询50次和1000行的限制； 2.修复原版jar包使用execute()和executeUpdate()方法报空指针异常的BUG。
PHP Version 7.4.30
03-07
1、动态网页开发； 2、服务器端脚本； 3、命令行脚本； 4、图像处理； 5、数据库操作；...6、版本控制系统；...它具有简单易学、跨平台、开源免费等优点，使其在网络应用开发领域具有...10. 支持从 __toString() 方法抛出异常
精选30道Java笔试题.doc
11-12
本文总结了精选30道Java笔试题中的关键知识点，涵盖了Java多线程、异常处理、字符串操作、构造函数等方面的知识。 1. 多线程知识点： * Thread类的方法：start()、run()、exit()等，其中exit()是System类的方法，...
内存出现异常怎么办.docx
09-27
内存出现异常怎么办.docx
Linux fallocate工具用于预分配或释放文件空间的块
不积跬步，无以至千里；不积小流，无以成江海。
06-09 309
命令，您需要在具有适当权限的环境中运行它，例如通过SSH登录到Linux服务器或在Linux终端中运行。请确保指定的路径存在且可写。文件中未使用的磁盘空间。请注意，这不会改变文件的大小，只是释放了未使用的磁盘空间。之前，建议了解文件系统和存储设备的特性，以避免潜在的性能问题。是一个Linux命令行工具，用于预分配或释放文件空间的块。文件的大小截断为5MB。大于5MB的部分将被删除。文件的10MB偏移量处开始预分配5MB的磁盘空间。文件的10MB偏移量处开始的5MB磁盘空间。文件预分配10MB的磁盘空间。
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 259
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
Linux Centos 环境下搭建RocketMq集群（双主双从）
最新发布
gonghua0502的专栏
06-15 340
worker2中配置两个文件：broker-a.properties、broker-b-s.properties。worker3中配置两个文件：broker-b.properties、broker-a-s.properties。启动顺序为：先启动3台服务器的nameserver，再启动worker2和worker3中的broker.worker1 只需要启动nameserver即可。
【Linux下的动态链接和静态链接 及 调用libevent库函数的可执行文件无法正常运行情况剖析】
一起学习进步！
06-09 323
静态链接是指在编译时，将程序所依赖的函数或数据直接复制到最终的可执行文件中。这意味着可执行文件包含了程序运行所需的所有代码和数据。动态链接是指在运行时，程序所依赖的函数或数据从外部的共享库（shared library）中加载。这意味着可执行文件只包含了必要的引用信息，而实际的代码和数据则存储在外部的共享库中。
socket.setdefaulttimeout(30)
07-16
通过调用`socket.setdefaulttimeout(30)`，我们可以将默认超时时间设置为30秒，从而在网络请求过程中，如果超过了这个时间仍未得到响应，就会抛出一个`socket.timeout`异常。这样可以避免程序长时间阻塞，提高代码的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

酷小洋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值