8.3 自定义异常及经验小结

最新推荐文章于 2024-06-15 14:36:25 发布
最新推荐文章于 2024-06-15 14:36:25 发布
阅读量140 收藏
点赞数
分类专栏： Java学习 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nytcjsjboss/article/details/132720368
版权

8.3 自定义异常及经验小结

在开发实践中很少用到自定义异常。因为在Java中已经定义好了非常多的异常类而且那些开源的框架中也有自己的异常类，所以不是写一些开源框架或者一些大型系统的情况下很少使用自定义异常。

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需集成Exception类即可

在程序中使用自定义异常类，大体可分为以下几个步骤：

  1. 创建自定义异常类
  2. 在方法中通过throw关键字抛出异常对象
  3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出**给方法调用者**的异常，继续进行下一步操作。
  4. 在出现异常方法的调用者中捕获并处理异常

自定义异常类的示例

  1. 自定义异常类需要继承Exception类才可以成为自定义的异常类

  2. 在Exception类中我们可以看到有很多的子类的，这些异常几乎满足了大部分的需求

  3. 定义完异常类需要自定义一些方法（我们可以从Java自带的异常类来学习如何写自定义异常类比如ArrayIndexOutOfBoundsException数组下标越界的异常类）

    package java.lang;

/**
 * Thrown to indicate that an array has been accessed with an
 * illegal index. The index is either negative or greater than or
 * equal to the size of the array.
 *
 * @author  unascribed
 * @since   JDK1.0
 */
public
class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
    private static final long serialVersionUID = -5116101128118950844L;

    /**
     * Constructs an <code>ArrayIndexOutOfBoundsException</code> with no
     * detail message.
     */
    public ArrayIndexOutOfBoundsException() {
        super();
    }

    /**
     * Constructs a new <code>ArrayIndexOutOfBoundsException</code>
     * class with an argument indicating the illegal index.
     *
     * @param   index   the illegal index.
     */
    public ArrayIndexOutOfBoundsException(int index) {
        super("Array index out of range: " + index);
    }

    /**
     * Constructs an <code>ArrayIndexOutOfBoundsException</code> class
     * with the specified detail message.
     *
     * @param   s   the detail message.
     */
    public ArrayIndexOutOfBoundsException(String s) {
        super(s);
    }
}

    从代码中我们可以看出ArrayIndexOutOfBoundsException继承了IndexOutOfBoundsException异常类，我们就去看这个父异常类IndexOutOfBoundsException

    public
class IndexOutOfBoundsException extends RuntimeException {
    private static final long serialVersionUID = 234122996006267687L;

    /**
     * Constructs an <code>IndexOutOfBoundsException</code> with no
     * detail message.
     */
    public IndexOutOfBoundsException() {
        super();
    }

    /**
     * Constructs an <code>IndexOutOfBoundsException</code> with the
     * specified detail message.
     *
     * @param   s   the detail message.
     */
    public IndexOutOfBoundsException(String s) {
        super(s);
    }
}

    代码中我们可以看出IndexOutOfBoundsException继承了一个运行时异常类RuntimeException

    package java.lang;

/**
 * {@code RuntimeException} is the superclass of those
 * exceptions that can be thrown during the normal operation of the
 * Java Virtual Machine.
 *
 * <p>{@code RuntimeException} and its subclasses are <em>unchecked
 * exceptions</em>.  Unchecked exceptions do <em>not</em> need to be
 * declared in a method or constructor's {@code throws} clause if they
 * can be thrown by the execution of the method or constructor and
 * propagate outside the method or constructor boundary.
 *
 * @author  Frank Yellin
 * @jls 11.2 Compile-Time Checking of Exceptions
 * @since   JDK1.0
 */
public class RuntimeException extends Exception {
    static final long serialVersionUID = -7034897190745766939L;

    /** Constructs a new runtime exception with {@code null} as its
     * detail message.  The cause is not initialized, and may subsequently be
     * initialized by a call to {@link #initCause}.
     */
    public RuntimeException() {
        super();
    }

    /** Constructs a new runtime exception with the specified detail message.
     * The cause is not initialized, and may subsequently be initialized by a
     * call to {@link #initCause}.
     *
     * @param   message   the detail message. The detail message is saved for
     *          later retrieval by the {@link #getMessage()} method.
     */
    public RuntimeException(String message) {
        super(message);
    }

    /**
     * Constructs a new runtime exception with the specified detail message and
     * cause.  <p>Note that the detail message associated with
     * {@code cause} is <i>not</i> automatically incorporated in
     * this runtime exception's detail message.
     *
     * @param  message the detail message (which is saved for later retrieval
     *         by the {@link #getMessage()} method).
     * @param  cause the cause (which is saved for later retrieval by the
     *         {@link #getCause()} method).  (A <tt>null</tt> value is
     *         permitted, and indicates that the cause is nonexistent or
     *         unknown.)
     * @since  1.4
     */
    public RuntimeException(String message, Throwable cause) {
        super(message, cause);
    }

    /** Constructs a new runtime exception with the specified cause and a
     * detail message of <tt>(cause==null ? null : cause.toString())</tt>
     * (which typically contains the class and detail message of
     * <tt>cause</tt>).  This constructor is useful for runtime exceptions
     * that are little more than wrappers for other throwables.
     *
     * @param  cause the cause (which is saved for later retrieval by the
     *         {@link #getCause()} method).  (A <tt>null</tt> value is
     *         permitted, and indicates that the cause is nonexistent or
     *         unknown.)
     * @since  1.4
     */
    public RuntimeException(Throwable cause) {
        super(cause);
    }

    /**
     * Constructs a new runtime exception with the specified detail
     * message, cause, suppression enabled or disabled, and writable
     * stack trace enabled or disabled.
     *
     * @param  message the detail message.
     * @param cause the cause.  (A {@code null} value is permitted,
     * and indicates that the cause is nonexistent or unknown.)
     * @param enableSuppression whether or not suppression is enabled
     *                          or disabled
     * @param writableStackTrace whether or not the stack trace should
     *                           be writable
     *
     * @since 1.7
     */
    protected RuntimeException(String message, Throwable cause,
                               boolean enableSuppression,
                               boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

    这段代码我们看出RuntimeException继承了Exception异常

    也就是说ArrayIndexOutOfBoundsException是好几个子类下面的，继承了四层关系，下面我们看一下这个异常是怎么写的，我们回到ArrayIndexOutOfBoundsException异常类的方法区

    package java.lang;

/**
 * Thrown to indicate that an array has been accessed with an
 * illegal index. The index is either negative or greater than or
 * equal to the size of the array.
 *
 * @author  unascribed
 * @since   JDK1.0
 */
public
class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
    private static final long serialVersionUID = -5116101128118950844L;

    /**
     * Constructs an <code>ArrayIndexOutOfBoundsException</code> with no
     * detail message.
     */
    public ArrayIndexOutOfBoundsException() {
        super();
    }

    /**
     * Constructs a new <code>ArrayIndexOutOfBoundsException</code>
     * class with an argument indicating the illegal index.
     *
     * @param   index   the illegal index.
     */
    public ArrayIndexOutOfBoundsException(int index) {
        super("Array index out of range: " + index);
    }

    /**
     * Constructs an <code>ArrayIndexOutOfBoundsException</code> class
     * with the specified detail message.
     *
     * @param   s   the detail message.
     */
    public ArrayIndexOutOfBoundsException(String s) {
        super(s);
    }
}

    我们可以看到异常类里面主要写了类的构造方法，构造方法是空参的是继承父类的，和实参的是继承父类的方法用来接收下标index。我们去父类看一下这个方法，也就是IndexOutOfBoundsException，在这个异常类中我们看到有参的构造方法又调用了父类的方法

    public IndexOutOfBoundsException(String s) {
        super(s);
    }

    我们接着去IndexOutOfBoundsException的父类RuntimeException看它的构造方法

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

    发现RuntimeException调用了他的父类Exception的构造方法，接着我们去Exception看

    package java.lang;

/**
 * The class {@code Exception} and its subclasses are a form of
 * {@code Throwable} that indicates conditions that a reasonable
 * application might want to catch.
 *
 * <p>The class {@code Exception} and any subclasses that are not also
 * subclasses of {@link RuntimeException} are <em>checked
 * exceptions</em>.  Checked exceptions need to be declared in a
 * method or constructor's {@code throws} clause if they can be thrown
 * by the execution of the method or constructor and propagate outside
 * the method or constructor boundary.
 *
 * @author  Frank Yellin
 * @see     java.lang.Error
 * @jls 11.2 Compile-Time Checking of Exceptions
 * @since   JDK1.0
 */
public class Exception extends Throwable {
    static final long serialVersionUID = -3387516993124229948L;

    /**
     * Constructs a new exception with {@code null} as its detail message.
     * The cause is not initialized, and may subsequently be initialized by a
     * call to {@link #initCause}.
     */
    public Exception() {
        super();
    }

    /**
     * Constructs a new exception with the specified detail message.  The
     * cause is not initialized, and may subsequently be initialized by
     * a call to {@link #initCause}.
     *
     * @param   message   the detail message. The detail message is saved for
     *          later retrieval by the {@link #getMessage()} method.
     */
    public Exception(String message) {
        super(message);
    }

    /**
     * Constructs a new exception with the specified detail message and
     * cause.  <p>Note that the detail message associated with
     * {@code cause} is <i>not</i> automatically incorporated in
     * this exception's detail message.
     *
     * @param  message the detail message (which is saved for later retrieval
     *         by the {@link #getMessage()} method).
     * @param  cause the cause (which is saved for later retrieval by the
     *         {@link #getCause()} method).  (A <tt>null</tt> value is
     *         permitted, and indicates that the cause is nonexistent or
     *         unknown.)
     * @since  1.4
     */
    public Exception(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new exception with the specified cause and a detail
     * message of <tt>(cause==null ? null : cause.toString())</tt> (which
     * typically contains the class and detail message of <tt>cause</tt>).
     * This constructor is useful for exceptions that are little more than
     * wrappers for other throwables (for example, {@link
     * java.security.PrivilegedActionException}).
     *
     * @param  cause the cause (which is saved for later retrieval by the
     *         {@link #getCause()} method).  (A <tt>null</tt> value is
     *         permitted, and indicates that the cause is nonexistent or
     *         unknown.)
     * @since  1.4
     */
    public Exception(Throwable cause) {
        super(cause);
    }

    /**
     * Constructs a new exception with the specified detail message,
     * cause, suppression enabled or disabled, and writable stack
     * trace enabled or disabled.
     *
     * @param  message the detail message.
     * @param cause the cause.  (A {@code null} value is permitted,
     * and indicates that the cause is nonexistent or unknown.)
     * @param enableSuppression whether or not suppression is enabled
     *                          or disabled
     * @param writableStackTrace whether or not the stack trace should
     *                           be writable
     * @since 1.7
     */
    protected Exception(String message, Throwable cause,
                        boolean enableSuppression,
                        boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

    从代码中我们可以看出Exception又调用了他的父类Throwable的构造方法，我们接着去Throwable中查看代码

        public Throwable(String message) {
        fillInStackTrace();
        detailMessage = message;
    }

    到了Throwable中发现构造方法没有再继承，而是写了方法体，也就是去打印这个message。所以这里我们就可以看出我们在自定义异常的时候需要自己写一个描述信息。

    于是我们就写了自己的自定义异常

    package com.baidu.www.exception.demo02;

/**
 * 1.普通类必须继承Exception才能成为自定义的异常类
 */
public class MyException extends Exception {
    //传递数字，如果数字大于10，就抛出异常
    private int detail;

    public MyException(int a) {
        this.detail = a;
    }
    //toString:异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

    首先我们自己先写一个描述信息，在上面的示例中我们是给异常类传递一个数字，当数字大于10的时候就抛出异常，抛出异常的时候需要给人们提出一些提示信息，首先第一个一个私有变量detail来接收这个数字，根据上面异常类的编写方法写一个构造器就可以了，所以我们写了一个消息的构造器，当然我们这里传递的是一个整型的数字。

    如果想要别人去打印这个信息就需要用到一个方法toString()方法。在IDEA中使用alt+insert快捷键插入toString方法

    接下来写一个测试来测试一下我们的自定义异常

    package com.baidu.www.exception.demo02;

public class Test {
    //写一个可能会存在异常的方法
    static void test(int a) throws MyException {
        System.out.println("传递的参数为："+a);
        if(a>10){
            throw new MyException(a);//抛出异常，也可以在方法内部捕获，如果在方法内部捕获，在方法外部就不用捕获了
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            //e.printStackTrace();
            System.out.println("MyException=>"+e);
        }
    }
}
/**
 * 传递的参数为：11
 * MyException=>MyException{detail=11}
 *
 * Process finished with exit code 0
 */

    首先我们要写一个可能存在异常的方法。在我们的测试方法test()中抛出异常，这里我们定义的方法中如果传递参数大于10就抛出异常。如果在方法中抛出异常就会告知我们有一个未知的异常需要处理一下，结局方法是可以在外面添加try-catch语句来捕获并处理异常，第二种方式在方法上将异常抛出去，抛到更高级别，让调用这个方法的时候再捕获这个异常并处理。

    在测试方法中我们可以看到，当程序调用测试方法时抛出了异常被捕获到，执行catch代码块中的语句，其中catch捕获到了MyException的异常，捕获到之后就执行catch代码块，e就是MyException中定义的toString方法。

实际应用中的经验总结

  1. 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理（因为用了try-catch就不至于程序突然的卡死）
  2. 在多重catch块后面，可以加上一个catch（Exception）来处理可能会被遗漏的异常
  3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常，在IDEA中如果有异常会出现红色的波浪线，使用alt+enter快捷键可以添加try-catch，或将异常抛出方法。
  4. 尽量去处理异常，切记只是简单的调用==printStackTrace（）==去打印输出（这是一个默认信息，使用快捷键生成异常处理块会自动生成的处理方式），而是使用一些判断语句进行异常的处理，如此一来就能减少损失。
  5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定（因为各种业务涉及的异常不同，比如银行金融、大小公司遇到的需求各不相同）
  6. 尽量添加finally语句块去释放占用的资源（尤其在IO流）
肆悟先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实验心得自定义异常_Java心得--自定义异常、断言
weixin_39560064的博客
02-26 333
1. 抛出异常Java运行时系统引发的异常根据需要人工创建并抛出人工抛出异常(被抛出的必须是Throwable或其子类的对象)语法格式：throw 异常类对象；例如：IOException e = new IOException();throw e;( 程序执行throw语句后立即终止，然后在包含它的所有try块中从里向外寻找含有与其类型匹配的catch子句。)2. 声明抛弃异常µ 如果一...
eWebEditorManual_V8.3_CHS.zip
12-17
本文将详细探讨eWebEditor V8.3的主要特性、操作方法及常见问题解决策略。 一、eWebEditor V8.3简介 eWebEditor是一款基于Web的富文本编辑器，允许用户在浏览器中直接进行文本编辑、格式化、图像处理和超链接设置...
如何自定义异常
m0_64624615的博客
08-14 194
如何自定义异常
Java 异常及解决方案系列（十二）：深入探讨自定义异常
最新发布
阿里渣渣java研发组-群主
06-15 355
自定义异常有助于更清晰地表达业务逻辑中的错误情况，提供更详细和有意义的错误信息。特定业务逻辑：标准异常无法准确描述某些业务逻辑中的错误。更好的错误信息：自定义异常可以提供更详细和上下文相关的错误信息。分类处理：通过自定义异常，可以更方便地对不同类型的错误进行分类处理。基础异常类可以继承Exception或，并提供基本的构造方法。在处理用户输入时，使用自定义异常可以更清晰地表达输入验证中的错误情况。
Java基础 第三节 第二十课
我是小白呀的博客
12-05 1604
自定义异常概述为什么需要自定义异常类什么是自定义异常类异常类如何定义自定义异常的练习 概述 为什么需要自定义异常类 我们说了 Java 中不同的异常类, 分别表示着某一种具体的异常情况. 那么在开发中总是有些异常情况是 SUN 没有定义好的, 此时我们根据自己业务的异常情况来定义异常类. 例如年龄负数问题, 考试成绩负数问题等等. 什么是自定义异常类 在开发中根据自己业务的异常情况来定义异常类. Ex: 自定义一个业务逻辑异常: RegisterException. 一个注册异常类. 异常类如何定义 自定
自定义异常
悟空非空也
07-06 1842
package cn.bdqn;/*如何自定义一个异常 * 1.自定义的异常类继承现有的异常类 * 2.提供一个序列号，提供几个重载的构造器 * * */ public class MyException extends Exception{ //static final long serialVersionUID = -3387516993124229948L; pub...
kiwisyslogdaemon-v8.3.25（日志服务器）
11-14
总结，Kiwi Syslogd v8.3.25是一款功能全面的日志服务器，适用于网络管理和故障排查，特别是对于Cisco设备的使用者，它提供了强大的日志收集和分析能力，是提升网络运维技能的得力助手。通过安装、配置和使用这款...
商业智能BI多维数据源及多维分析.doc
04-22
8.1 多维分析（OLAP）是商业智能的核心，它允许用户从多个角度和不同深度探索数据，以揭示隐藏的模式、趋势和异常。这种技术通过立方体和多维报表来实现，使得用户能够快速生成定制化的业务分析报告。 8.2 立方体是...
Visual C++ 2005入门经典--源代码及课后练习答案
02-02
1.7　小结 29 第2章　数据、变量和计算 31 2.1　C++程序结构 31 2.1.1　程序注释 36 2.1.2　#include指令——头文件 37 2.1.3　命名空间和using声明 37 2.1.4　main()函数 38 2.1.5　程序语句 38 2.1.6　...
Visual C# 2008核心编程及源代码(共12个分卷)
02-02
作者： (美)Donis Marshall [作译者介绍] 译者： 施平安 王净 蔡兴泉 丛书名： 微软技术丛书 出版社：清华大学出版社 目录回到顶部↑ 第i部分 核心语言....第1章 visual c#编程简介 3 ...18.2 小结 590 索引... 591
自定义异常的两种方式
蒲松龄
05-04 3522
自定义异常的两种方式 一、抛出异常 def greet(name, city): if not isinstance(name, str): raise TypeError("Name must be str") if not isinstance(city, str): raise TypeError("Age must be str") ...
07 Java异常机制（三）——自定义异常
weixin_46307478的博客
09-09 57
三、自定义异常 package com.exception.demo02; //自定义异常类 public class MyException extends Exception { //传递数字>10 private int detail; public MyException(int a) { this.detail = a; } @Override public String toString() { re
Java的异常类、自定义异常类及使用场景
qq_43296327的博客
01-09 466
自定义异常类必须继承于Exception或者RuntimeException类继承Exception的话：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译器异常，就必须处理这个异常，要么Try….catch或者throws继承RuntimeException的话：那么这个自定义的异常类就是一个运行期异常，无需处理，直接抛，直接交给虚拟机处理（中断处理）自定义异常类需要定义两个构造方法：一个无参构造、一个有参构造。
异常,自定义异常,一个简单明了的理解过程
zhangwenzheng0526的博客
09-11 1141
在之前的学习中我们学过IO流,在IO流中使用字符缓冲流(BufferedReader bf =newBufferedReader(new FileReader("abc.txt"));)的时候除了需要导包意外,还需要进行抛异常:import java.io.IOException;         那么这个异常是什么,为什么要抛异常,抛异常能解决什么问题呢,今天的学习以后,让我对异常的用处有了了
创建一个自定义异常
m0_73960392的博客
05-21 1442
在应用程序中，您可以使用 throw 关键字抛出自定义异常。} }这将抛出一个自定义异常，其中包含了一个错误信息。当自定义异常被抛出时，您可以使用 try-catch 语句来捕获并处理异常。try {这将捕获MyException类型的异常，并在catch区块中处理异常。
如何自定义异常，自定义异常的基本步骤，解析异常的使用
weixin_47198217的博客
07-25 2965
java实战，自定义异常案例，与异常复习
如何自定义异常Java
weixin_74077856的博客
06-29 3414
情况确实如此，无论是在Java自带异常还是，用户自定义异常，他们都是去掉用父类有参或者无参构造方法，异常这种一层一层的去调用父类构造方法，是异常发生的基本流程，最终干实事的是最终类Throwable，所以上述的我的自定义的异常是符合异常的基本规范的，最后的是如何去使用自定义的编译时异常去规范我们的程序呢，下面是我对异常的使用，如图。这样看是不是舒服多了，自定义编译时异常的功能用处广泛，应用的方向广泛，也体现Java高度面向对象的包容性。下面是他的具体用法，如图。下面是控制台输出，如图。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值