83-Java异常：处理机制、案例、自定义异常

最新推荐文章于 2023-09-06 17:40:46 发布
最新推荐文章于 2023-09-06 17:40:46 发布
阅读量686 收藏 1
点赞数
分类专栏： JavaSE基础进阶篇 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelitoudu/article/details/126759010
版权
本文详细介绍了Java的异常处理机制，包括编译时异常和运行时异常的处理方式。强调了try-catch-finally、throws关键字的使用，以及自定义异常类的重要性。通过实例展示了如何通过异常处理确保代码的稳健性，特别是在处理用户输入和业务逻辑时避免程序崩溃。同时，提出了在实际开发中，推荐使用异常处理方式三是最佳实践，即在底层抛出异常，由最外层集中捕获处理。
摘要由CSDN通过智能技术生成

一、异常处理机制

1、编译时异常的处理机制
  • 编译时异常是编译阶段就会报错！所以必须进行处理，否则代码无法通过！
2、编译时异常的三种处理形式
  • 出现异常直接抛出给调用者，调用者继续抛出去。
  • 出现异常自己捕获处理，不麻烦别人。
  • 前两者结合，出现异常直接抛出给调用者，调用者捕获处理。
（1）异常处理方式一
  • 关键字：throws，用在方法上，可以将方法内部出现的异常抛出去给本方法的调用者处理。
  • 这种方式并不好，发生异常的方法自己不处理异常，如果异常最终抛出去给JVM虚拟机将引起程序终止。
（1-1）抛出异常格式
方法 throws 异常1, 异常2, 异常3, ...{
    
}

package com.app.d8_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
    目标：掌握编译时异常处理方式一，并清楚其缺陷
    方式一：
        在出现编译时异常的地方层层把异常抛出去给调用者，调用者最终抛出给JVM虚拟机。
        JVM虚拟机输出异常信息，直接终止程序，这种方式与默认方式是一样的。
        虽然可以解决代码编译时的报错！但是一旦运行时真的出现异常，就会终止程序，项目也无法正常运行！
        因此，这种方式并不好！！
 */
public class ExceptionDemo1 {
    public static void main(String[] args) throws ParseException, FileNotFoundException {
        System.out.println("程序开始...");
        parseTime("2022-09-07 14:33:22");
        System.out.println("程序结束.");
    }

    public static void parseTime(String date) throws ParseException, FileNotFoundException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");  // 运行时会报错！
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        // 不需要理解这行代码的意义
        InputStream is = new FileInputStream("E:/ab.jpg");    // 当上一步代码没有bug时，JVM虚拟机才会检测到这里的异常！
    }
}

  • 这里可以看到出现了一个编译时异常了：

    在这里插入图片描述

  • 直接使用throws关键字，将异常抛出给调用者：

    在这里插入图片描述

  • 调用者也直接使用throws关键字，将异常抛出给JVM虚拟机：

    在这里插入图片描述

  • 在编译阶段已经看不到出错了！将异常抛出给JVM虚拟机时，当程序没有bug，就可以正常运行：

    在这里插入图片描述

  • 将异常抛出给JVM虚拟机时，当程序有bug，JVM虚拟机就会输出异常信息，程序终止：

    在这里插入图片描述

  • 注意：

    在这里插入图片描述

    在这里插入图片描述

  • 小结：无论你使用throws抛出多少个异常，其实真正抛出的只有一个异常，只有处理完前一个的bug，JVM虚拟机才会检测到后一个的bug。
（1-2）规范做法
方法 throws Exception {
    
}

package com.app.d8_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
    目标：掌握编译时异常处理方式一，并清楚其缺陷
    方式一：
        在出现编译时异常的地方层层把异常抛出去给调用者，调用者最终抛出给JVM虚拟机。
        JVM虚拟机输出异常信息，直接终止程序，这种方式与默认方式是一样的。
        虽然可以解决代码编译时的报错！但是一旦运行时真的出现异常，就会终止程序，项目也无法正常运行！
        因此，这种方式并不好！！
 */
public class ExceptionDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("程序开始...");
        parseTime("2022-09-07 14:33:22");
        System.out.println("程序结束.");
    }

    public static void parseTime(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");  // 运行时会报错！
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        // 不需要理解这行代码的意义
        InputStream is = new FileInputStream("E:/ab.jpg");    // 当上一步代码没有bug时，JVM虚拟机才会检测到这里的异常！
    }
}
（1-3）总结：这种方式不好！
（2）异常处理方式二
  • try...catch...
    • 监视捕获异常，用在方法内部，可以将方法内部出现的异常直接捕获处理。
    • 这种方式还可以，发生异常的方法自己独立完成异常的处理，程序可以继续往下执行。
（2-1）格式
try{
    // 监视可能出现异常的代码！
}catch(异常类型1 变量) {
    // 处理异常
}catch(异常类型2 变量) {
    // 处理异常
}...
（2-2）单独处理（不推荐）
package com.app.d8_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
    目标：掌握编译时异常处理方式二，并清楚其作用
    方式二：
        在编译阶段，监视捕获异常，发生异常的方法自己独立完成异常的处理，
        这样程序就可以继续往下执行，不会终止！
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        parseTime("2022-09-07 14:33:22");
        System.out.println("程序结束.");
    }

    public static void parseTime(String date) {
        try {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");  // 运行时会报错！
            Date d = sdf.parse(date);
            System.out.println(d);
        } catch (ParseException e) {
            // 解析出现的问题
            System.out.println("出现了解析时间异常！！");
        }

        try {
            // 不需要理解这行代码的意义
            InputStream is = new FileInputStream("E:/ab.jpg");
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件！！");
        }
    }
}

程序开始...
出现了解析时间异常！！
找不到指定文件！！
程序结束.

Process finished with exit code 0
  • 可以看到，使用try...catch...监视捕获异常后，程序可以正常的运行完成！！即使存在异常，也不会让程序立即终止！！
（2-3）整体处理（推荐）
package com.app.d8_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
    目标：掌握编译时异常处理方式二，并清楚其作用
    方式二：
        在编译阶段，监视捕获异常，发生异常的方法自己独立完成异常的处理，
        这样程序就可以继续往下执行，不会终止！
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        parseTime("2022-09-07 14:33:22");
        System.out.println("程序结束.");
    }

    public static void parseTime(String date) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");  // 运行时会报错！
            Date d = sdf.parse(date);
            System.out.println(d);

            // 不需要理解这行代码的意义
            InputStream is = new FileInputStream("E:/ab.jpg");	// 当前面的代码没有bug时，才会检测到此处的bug
        } catch (ParseException e) {
            // 解析出现的问题
            System.out.println("出现了解析时间异常！！");
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件！！");
        }
    }
}


程序开始...
出现了解析时间异常！！
程序结束.

Process finished with exit code 0
  • 可以看到，方法内部的前面的代码出现了异常，因此后面的代码不会执行，但是不会终止程序的运行！！
  • 既然已经出现了异常，那就先解决前面的异常，再去捕获后面的异常，再进行解决！！
（2-4）建议格式（企业级写法）
  • Exception可以捕获处理一切异常类型
try{
    // 可能出现异常的代码！
}catch(Exception e) {
    e.printStackTrace();	// 直接打印异常栈信息
}

package com.app.d8_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
    目标：掌握编译时异常处理方式二，并清楚其作用
    方式二：
        在编译阶段，监视捕获异常，发生异常的方法自己独立完成异常的处理，
        这样程序就可以继续往下执行，不会终止！
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        parseTime("2022-09-07 14:33:22");
        System.out.println("程序结束.");
    }

    public static void parseTime(String date) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");  // 运行时会报错！
            Date d = sdf.parse(date);
            System.out.println(d);

            // 不需要理解这行代码的意义
            InputStream is = new FileInputStream("E:/ab.jpg");  // 当前面的代码没有bug时，才会捕获到此处的bug
        } catch (Exception e) {
            // 解析出现的异常
            e.printStackTrace();    // 调用printStackTrace方法，打印异常栈信息（规范）
        }
    }
}

在这里插入图片描述

（2-5）异常处理方式三
  • 前两种处理方式的结合体
    • 方法直接将异常通过throws抛出去给调用者；
    • 调用者收到异常后直接捕获处理。
  • 出现第三种方式的原因：
    • 举个例子：
      • 我请小王帮我去买一支笔，小王很牛的说：“我干嘛帮你买？”，随后小王让小白去帮我买，小白去了。
      • 结果小白到的时候，店已经打烊了，此时小白发现了异常，然后小白自己独立处理掉了这个异常！
      • 之后，小王就懵了，啥情况都不知道！
      • 最后，我也懵了！！不知道笔买了还是没买！
    • 如果异常都在底层独立处理完了，那我根本不知道底层到底是成功了还是失败了！！
package com.app.d8_exception_handle;

import java.io.FileInputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
    目标：掌握编译时异常处理方式三，并清楚其作用
    方式三：
        在编译阶段，将异常抛出去给调用者，调用者再使用try...catch...捕获处理异常，
        这样的好处是调用者既能了解到底层的执行情况，又能让程序继续往下执行，不会终止！
 */
public class ExceptionDemo3 {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        try {
            parseTime("2022-09-07 14:33:22");
            System.out.println("功能操作成功~");
        } catch (Exception e) {
            e.printStackTrace();    // 调用printStackTrace方法，打印异常栈信息（规范）
            System.out.println("功能操作失败！");
        }
        System.out.println("程序结束.");
    }

    public static void parseTime(String date) throws Exception {
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd HH:mm:ss");  // 运行时会报错！
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        // 不需要理解这行代码的意义
        InputStream is = new FileInputStream("E:/ab.jpg");  // 当前面的代码没有bug时，才会捕获到此处的bug
    }
}

在这里插入图片描述

总结

1、异常处理的总结

  • 开发中按照规范来说第三种方式是最好的：底层的异常抛出去给最外层，最外层集中捕获处理。好处就是外层可以知道底层是否执行成功。
  • 实际应用中，只要代码能通过编译阶段，并且功能可以完成 ，那么每一种异常处理方式似乎也都是可以的。
3、运行时异常的处理机制
  • 运行时异常编译阶段不会报错，是运行时才可能报错的，所以编译阶段不处理也可以。
  • 按照规范建议还是处理：建议在最外层调用处集中捕获处理即可。
package com.app.d9_exception_handle_runtime;

/**
    目标：运行时异常的处理机制
    可以不处理，编译阶段代码也通过了
    按照理论规则：建议还是处理，只需要在外层捕获处理异常即可！
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        try {
            chu(10, 0);
            System.out.println("操作成功！");
        } catch (Exception e) {
            System.out.println("出现异常！");
            e.printStackTrace();    // 打印异常栈信息
        }
        System.out.println("程序结束.");
    }

    public static void chu(int a, int b) {
        System.out.println(a);
        System.out.println(b);
        int c = a / b;
        System.out.println(c);
    }
}

在这里插入图片描述

二、异常处理使代码更稳健的案例

1、案例一

需求：

  • 键盘录入一个合理的价格为止（必须是数值，值必须大于0）。

分析：

  • 定义一个死循环，让用户不断的输入价格。

未处理异常前：

package com.app.d10_exception_handle_test;

import java.util.Scanner;

/**
    目标：通过案例清楚并理解异常在实际开发中的作用
 */
public class Test1 {
    public static void main(String[] args) {
        // 需求：键盘录入一个合理的价格为止（必须是数值，值必须大于0）

        // a、创建键盘录入对象，用于用户录入价格
        Scanner sc = new Scanner(System.in);

        // b、定义死循环，让用户不断输入价格，直到输入的价格合理为止
        while (true) {
            System.out.println("请您输入一个价格：");
            // c、定义一个字符串变量用于存放用户输入的价格
            /*
                为啥用String接收，而不是用double接收？？
                因为用户难免会输错！！比如：23.2jjghj 等等
             */
            String priceStr = sc.nextLine();
            // d、将接收到的String类型的价格转换成double类型的价格
            double price = Double.valueOf(priceStr);

            // e、判断用户输入的价格是否大于0
            if (price > 0) {
                // 是，说明价格是正数
                System.out.println("定价：" + price);
                break;
            }else {
                // 否，说明价格不是正数
                System.out.println("sorry！输入的价格必须是正数哦~~");
            }
        }
    }
}
  • 可以看到，用户如果输入负数，判断正常；用户输入合理价格，也正常！

在这里插入图片描述

  • 但是，有个问题，假如用户这样子输入呢？
  • 这样子，就会出现数据类型转换异常：NumberFormatException，如果不处理异常，程序就会死亡、终止！

在这里插入图片描述

处理异常后：

package com.app.d10_exception_handle_test;

import java.util.Scanner;

/**
    目标：通过案例清楚并理解异常在实际开发中的作用
 */
public class Test1 {
    public static void main(String[] args) {
        // 需求：键盘录入一个合理的价格为止（必须是数值，值必须大于0）

        // a、创建键盘录入对象，用于用户录入价格
        Scanner sc = new Scanner(System.in);

        // b、定义死循环，让用户不断输入价格，直到输入的价格合理为止
        while (true) {
            try {
                System.out.println("请您输入一个价格：");
                // c、定义一个字符串变量用于存放用户输入的价格
            /*
                为啥用String接收，而不是用double接收？？
                因为用户难免会输错！！比如：23.2jjghj 等等
             */
                String priceStr = sc.nextLine();
                // d、将接收到的String类型的价格转换成double类型的价格
                double price = Double.valueOf(priceStr);

                // e、判断用户输入的价格是否大于0
                if (price > 0) {
                    // 是，说明价格是正数
                    System.out.println("定价：" + price);
                    break;
                }else {
                    // 否，说明价格不是正数
                    System.out.println("sorry！输入的价格必须是正数哦~~");
                }
            } catch (Exception e) {
                System.out.println("您输入的价格不合理，请重新输入一个合理的价格！");
            }
        }
    }
}
  • 可以看到，处理异常后，当出现异常时，就可以捕获处理掉，就不会让程序死亡、终止！！

在这里插入图片描述

三、自定义异常

  • Java无法为这个世界上全部的问题提供异常类。
  • 如果企业想通过异常的方式来管理自己的某个业务问题，就需要自定义异常类了。
1、好处
  • 可以使用异常的机制管理业务问题，如提醒程序员注意。
  • 同时一旦出现bug，可以用异常的形式清晰的指出出错的地方。
2、分类
（1）自定义编译时异常
  • 定义一个异常类继承Exception。
  • 重写构造器。
  • 在出现异常的地方用throws new自定义对象抛出。
  • 作用：编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！

在这里插入图片描述

在这里插入图片描述

package com.app.d11_exception_custom;

/**
    目标：学会自定义异常类（了解）
    自定义异常类：
        1、自定义编译时异常
        2、自定义运行时异常

    需求：年龄小于0岁 或 大于200岁，就为异常
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        // 模拟调用者使用checkAge方法
        try {
            checkAge(13);
            checkAge(-23);
        } catch (AgeIsIllegalException e) {
            e.printStackTrace();
        }
    }

    public static void checkAge(int age) throws AgeIsIllegalException {
        if (age < 0 || age > 200) {
            // 抛出去一个异常给对象给调用者
            // throw：在方法内部直接创建一个异常对象，并从此点抛出
            // throws：用在方法申明上的，抛出方法内部的异常
            throw new AgeIsIllegalException(age + " is illegal！");
        }else {
            System.out.println(age + "岁，年龄合法！");
        }
    }
}

在这里插入图片描述

（2）自定义运行时异常
  • 定义一个异常类继承RuntimeException。
  • 重写构造器。
  • 在出现异常的地方用throws new自定义对象抛出。
  • 作用：运行时异常是编译阶段不报错，提醒不强烈，运行时才可能出现错误！

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

总结

1、自定义编译时异常

  • 定义一个异常类继承Exception；
  • 重写构造器；
  • 在出现异常的地方用throw new自定义对象抛出；
  • 作用：编译时异常是编译阶段就报错！提醒更加强烈，一定需要处理异常！！

2、自定义运行时异常

  • 定义一个异常类继承RuntimeException；
  • 重写构造器；
  • 在出现异常的地方用throw new自定义对象抛出；
  • 作用：提醒不强烈，编译阶段不会报错！运行时才可能会报错！
学不会is dog
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java异常处理-异常处理的方式1
01-12
- 案例4：处理自定义异常时，可以创建一个继承自`Exception`的类，并在`catch`中捕获。 在实际编程中，`finally`块常用于关闭打开的流或其他需要释放的资源。例如： ```java FileInputStream fis = null; try { ...
Java 异常艺术：自定义异常的魔力-解锁编程的新维度.pdf
最新发布
07-14
### Java 异常艺术：自定义异常的魔力——解锁编程的新维度 #### 第一部分：异常的基石 在 Java 编程中，异常处理是一项重要的技术，它帮助开发者优雅地应对程序运行期间可能出现的各种错误情况。Java 提供了一个...
Java如何自定义异常？
qq_68384595的博客
09-27 1万+
如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：把异常的名称，错误原因及异常出现的位置等信息输出在了控制台程序停止执行。程序从 try 里面的代码开始执行出现异常，就会跳转到对应的 catch 里面去执行执行完毕之后，程序还可以继续往下执行提示：以下是本篇文章正文内容，下面案例可供参考这个类是自定义异常的类，首先我们进行继承idea的RuntimeException，其次建立有参和无参的方法。}super(s);
8 Java程序设计-异常处理-自定义异常类
m0_73909652的博客
03-14 1080
8 Java程序设计-异常处理-自定义异常类
Java异常详解及自定义异常
Java后端技术栈
12-05 2万+
异常的定义 异常就是有异于常态，和正常情况不一样，有错误出现。在java中，阻止当前方法或作用域的情况，称之为异常。 异常的分类 Error：是程序中无法处理的错误，表示运行应用程序中出现了严重的错误。此类错误一般表示代码运行时JVM出现问题。通常有Virtual MachineError（虚拟机运行错误）、NoClassDefFoundError（类定义错误）等。比如说当jvm耗完可用内存时，将出现OutOfMemoryError。此类错误发生时，JVM将终止线程。非代码性错误。因此..
【Java】Java中的自定义异常
yao_yaoya的博客
11-23 3173
使用java内置的异常类可以描述在编程时出现的大部分异常情况。初次之外，用户还可以自定义异常。用户自定义异常类，只需要继承**Exception**类即可。
PTA 8 Java程序设计-异常处理-自定义异常类 分数 10
weixin_73692078的博客
04-06 1946
用户只需要继承Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为以下几个步骤：1、创建自定义异常类。2、在方法中通过。
Java软件开发实战 Java基础与案例开发详解 10-1 java异常处理 共7页.pdf
07-07
以上是对Java异常处理核心知识点的详细总结，涵盖了异常的基础概念、异常处理的主要机制以及如何使用这些机制来编写健壮可靠的Java程序。通过学习这些内容，开发者可以更好地理解和掌握Java异常处理机制，从而提高...
curso-java-basico：Java语言的高级实践
02-14
5. **异常处理**：学习Java的异常处理机制，包括try-catch-finally块和throw、throws关键字，以及自定义异常的创建。 6. **集合框架**：熟悉ArrayList、LinkedList、HashSet、HashMap等数据结构，理解它们的工作...
java实现系统捕获异常发送邮件案例
09-01
总结来说，Java实现系统捕获异常发送邮件的案例涉及了Java异常处理机制、Java Mail API的使用以及自定义数据结构（如枚举和类）来封装和管理邮件相关信息。这样的功能对于实时监控和故障排查非常有用，尤其是在大型...
Java 自定义异常和抛出异常
06-14
Java 自定义异常和抛出异常的练习demo
04Java异常-8. 自定义异常的使用
学无止境
08-05 116
04Java异常-8. 自定义异常的使用*
8.3 自定义异常及经验小结
nytcjsjboss的博客
09-06 150
在开发实践中很少用到自定义异常。因为在Java中已经定义好了非常多的异常类而且那些开源的框架中也有自己的异常类，所以不是写一些开源框架或者一些大型系统的情况下很少使用自定义异常。使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需集成Exception类即可创建自定义异常类在方法中通过throw关键字抛出异常对象如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；
JAVA中自定义异常方法抛出异常
weixin_44548405的博客
04-19 2021
开发工具与关键技术：JAVA中的自定义异常 作者：邓崇富 撰写时间：2019 年 4 月 26 日 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 一、通过throw抛出异常 使用java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需要集成E...
Android开发课程-功底Java
08-23
本套课程是一套全面、细致、深入的Java开发教程，课程共计19个章节，从基础语法、面向对象到设计模式、算法、网络编程、多线程、IO、集合框架、反射、泛型、正则表达式、常用工具类等内容进行了深入细致的讲解。
Java 如何抛出异常、自定义异常
热门推荐
风中的劲草
06-13 32万+
一、异常的抛出 1、定义 ： 一个方法不处理这个异常，而是调用层次向上传递，谁调用这个方法，这个异常就由谁来处理。2、throw : 将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内）3、throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异
Java中如何自定义一个异常类
pipizhen_的博客
07-16 5169
java中可以自定义异常类吗？ SUN公司提供的JDK内置的异常类肯定是不够用的。在实际开发中，有很多业务，这些业务出现异常之后，JDK中都是没有的，和业务挂钩的。那么异常类我们可以自己定义吗？ 答案是可以的。 java中怎么自定义异常类？ 分两步： 第一步：编写一个类，继承Exception，或者继承RuntimeException； 第二步：提供两个构造方法，一个无参数的，一个带有String参数的。有参数方法体中写super(s)即可。 测试代码： public class Test13 {
Java自定义异常
weixin_47556601的博客
01-22 5711
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Excepition类即可 在程序当中自定义异常类，大体可以分成几个步骤： 1.创建自定义异常类 2.在方法中通过throw关键字指明要抛出异常对象。 3.如果当前抛出异常的方法中处理异常，可以使用try-catch语法捕获并处理；否则在方法的声明处通过throw关键字指明要抛出给方法调用者的异常，继续进行下一步操作 4.在出现异常方法的调用者中捕获并处理异常。 上源码 package E
Java自定义异常示例
一名可爱的技术搬运工
05-31 6367
在Java中，有两种类型的异常-已检查和未检查的异常。 这是摘要： 已检查 -扩展java.lang.Exception ，以获取可恢复的条件，尝试尝试捕获异常，并编译错误。 未选中 -扩展java.lang.RuntimeException ，以恢复不可恢复的条件，例如编程错误，无需try-catch，运行时错误。 1.自定义检查异常 注意 一些流行的检查异常： ...
自定义Java异常处理：实例与实战
本资源主要探讨了Java中的自定义异常类及其应用，以及相关的课后练习，旨在帮助开发者理解和掌握如何在实际开发中灵活运用异常处理机制。 首先，自定义异常类的重要性在于能够针对特定的业务逻辑和错误情况进行定制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值