精华内容
下载资源
问答
  • 11.7.1编写自定义异常类的模式 编写自定义异常类实际上是继承一个API标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下: public class CustomException extends ...

    11.7.1  编写自定义异常类的模式

    编写自定义异常类实际上是继承一个API标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下:

     

    public class CustomException extends Exception {    //或者继承任何标准异常类
        public CustomException()  {}                //用来创建无参数对象
        public CustomException(String message) {        //用来创建指定参数对象
            super(message);                             //调用超类构造器
        }
    }

     

    当然也可选用Throwable作为超类。其中无参数构造器为创建缺省参数对象提供了方便。第二个构造器将在创建这个异常对象时提供描述这个异常信息的字符串,通过调用超类构造器向上传递给超类,对超类中的toString()方法中返回的原有信息进行覆盖。
    来讨论一个具体例子。假设程序中需要验证用户输入的表示年龄的数据必须是正整数值。我们可以按照以上模式编写这个自定义异常类如下:

     

    public class NegativeAgeException extends Exception {
                                                //或者:extends Throwable
        public NegativeAgeException()  {}
        public NegativeAgeException(String message) {
            super(message);
        }
    }

     

    下面是应用这个自定义异常类的例子:

     

    //完整程序存在本书配套资源目录为Ch11中名为NegativeAgeExceptionTest.java
    ...
    try{
       String ageString = JOptionPane.showInputDialog("Enter your age: ");

     

       if (Integer.parseInt(ageString) < 0)
            throw new NegativeAgeException("Please enter a positive age");
       else
            JOptionPane.showMessageDialog(null, ageString, "Age", 1);
    }
    catch(NegativeAgeException e){
        System.out.println(e);
    }
    ...

     

    或者,可以创建一个缺省对象,然后在catch中打印具体信息,如:

     

        throw new NegativeAgeException();
        ...
    catch (NegativeAgeException e) {
        System.out.println("Please enter a positive age");

     

     

    将产生与第一个例子相同的效果。

    11.7.2  自定义异常处理

    无论是利用标准API异常类来处理特殊的异常,或者编写自定义的异常类来达到同样目的,问题的关键是:
    1.         当这个异常发生时,如何及时捕获这个异常。
    2.         捕获这个异常后,如何产生精确的异常处理信息。
           毋庸置疑,我们不可能期待JVM自动抛出一个自定义异常,也不能够期待JVM会自动处理一个自定义异常。发现异常、抛出异常以及处理异常的工作必须靠编程人员在代码中利用异常处理机制自己完成。
    一般情况下,发现和抛出一个自定义异常通过在try程序块中利用ifthrow语句完成,即:

     

    try {
        ...
        if (someExceptionConditon == true) {
            throw new CustomException("A custom exception xxx occurred. Please
            check your entry...")
        ...
        }
    catch (CustomException e) {
        ...
    }

     

    而打印异常处理信息可以在抛出时包括在构造器的参数中,或者包括在处理这个异常的catch中。
    另外应该注意在自定义异常发生之前,有可能产生标准异常的情况。例如,在一个需要验证年龄必须是正整数值的程序中,利用自定义异常类,如NegativeAgeException,验证输入的年龄是否正整数,即:

     

    try {
        ...
        if (Integer.parseInt(ageString) < 0)     
            throw NegativeAgeException("Please enter a positive age");
        else
            ...
        }
        catch (NumberFormatException e) {
            System.out.println(e);
        }
        catch (NegativeAgeException e) {
            System.out.println(e);
        }
        ...

     

    注意在这个代码中,如果ageString是非法整数字符串,如“25ab”,系统将首先抛出NumberFormatException,而不会执行throw NegativeAgeException("Please enter a positive age")。所以应该在catch中加入对NumberFormatException的处理,如以上代码所示。

     



















    本文转自高永强51CTO博客,原文链接: 

    http://blog.51cto.com/yqgao/174767,如需转载请自行联系原作者


    展开全文
  • java自定义异常类

    2020-06-25 19:18:09
    java自定义异常类 1.语法  一般地,用户自定义异常类都是RuntimeException的子类。  自定义异常类通常需要编写几个重载的构造器。  自定义异常需要提供serialVersionUID  自定义的异常通过throw抛出。  ...

    java中自定义异常类

    1.语法
     一般地,用户自定义异常类都是RuntimeException的子类。
     自定义异常类通常需要编写几个重载的构造器。
     自定义异常需要提供serialVersionUID
     自定义的异常通过throw抛出。
     自定义异常最重要的是异常类的名字,当异常出现时,可以根据名字判断异常类型。

    2.举例
    用户自定义异常类MyException,用于描述数据取值范围错误信息。用户自己的异常类必须继承现有的异常类。

    class MyException extends Exception {
    	static final long serialVersionUID = 13465653435L;
    	private int idnumber;
    	public MyException(String message, int id) {
    		super(message);
    		this.idnumber = id;
    	}
    	public int getId() {
    		return idnumber;
    	}
    }
    
    public class MyExpTest {
    	public void regist(int num) throws MyException {
    		if (num < 0)
    		throw new MyException("人数为负值,不合理", 3);
    		else
    		System.out.println("登记人数" + num);
    	}
    	public void manager() {
    		try {
    			regist(100);
    		} catch (MyException e) {
    			System.out.print("登记失败,出错种类" + e.getId());
    		}
    		System.out.print("本次登记操作结束");
    	}	
    	public static void main(String args[]) {
    		MyExpTest t = new MyExpTest();
    		t.manager();
    	}
    }
    
    展开全文
  • // 创建自定义异常类的实例,并不抛出,测试自定义异常类 /*MyStackOperatorException e = new MyStackOperatorException("栈操作有误"); String msg = e.getMessage(); System.out.println(msg)

    测试代码:

    public class Test13 {
        public static void main(String[] args) {
            // 创建自定义异常类的实例,并不抛出,测试自定义异常类
            /*MyStackOperatorException e = new MyStackOperatorException("栈操作有误");
            String msg = e.getMessage();
            System.out.println(msg);  // 栈操作有误
            e.printStackTrace();  // exception.MyStackOperatorException: 栈操作有误
            // at exception.Test13.main(Test13.java:23)*/
    
            // 自定义异常完成栈满压栈异常,栈空出栈异常
            try {
                MyStack stack = new MyStack(5);
    
                stack.push(1);
                stack.push(2);
                stack.push(3);
                stack.push(4);
                stack.push(5);
                // 已压栈5次,下面必出异常
                stack.push(6);
    
            } catch (MyStackOperatorException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    // 自定义异常类
    class MyStackOperatorException extends Exception {
        public MyStackOperatorException() {
        }
        public MyStackOperatorException(String s) {
            super(s);
        }
    }
    
    // 自定义栈,能存储任意引用类型
    class MyStack {
        //栈数组
        private Object[] elements;
        //栈长度
        private int length;
        //栈针
        private int index;
    
        //外部只能读取 栈的大小 和 栈针的位置
        public int getLength() {
            return length;
        }
        public int getIndex() {
            return index;
        }
    
        //只给一个参数的构造方法,要求确定栈数组的大小
        public MyStack(int length) throws MyStackOperatorException {
            //假设栈的长度不能超过100
            if (length <= 0 || length >= 100){
                throw new MyStackOperatorException("栈长度不合法,创建失败");
            }
            this.length = length;
            this.index = 0;
            elements = new Object[length];
            System.out.println("成功初始化长度为" + length + "的栈");
        }
    
        //压栈
        void push(Object obj) throws MyStackOperatorException{
            if (index == length) {
                throw new MyStackOperatorException("栈已存满,压栈失败");
            }
            elements[index] = obj;
            index++;
            System.out.println("压栈成功,栈中已存储" + index + "个数据");
        }
    
        //出栈
        Object pop() throws MyStackOperatorException {
            if (index == 0) {
                throw new MyStackOperatorException("栈是空的,出栈失败");
            }
            index--;
            System.out.println("出栈成功,栈中剩余" + index + "个数据");
            return elements[index];
        }
    }
    

    展开全文
  • java自定义异常类

    2016-12-21 16:37:00
    编写自定义异常类的模式 编写自定义异常类实际上是继承一个Exception标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下: public classCustomException extends ...

    编写自定义异常类的模式

    编写自定义异常类实际上是继承一个Exception标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下:

     

    public classCustomException extends Exception {    //或者继承任何标准异常类

        public CustomException()  {}                //用来创建无参数对象

        public CustomException(String message){        //用来创建指定参数对象

            super(message);                            //调用超类构造器

        }

    }

     

    当然也可选用Throwable作为超类。其中无参数构造器为创建缺省参数对象提供了方便。第二个构造器将在创建这个异常对象时提供描述这个异常信息的字符串,通过调用超类构造器向上传递给超类,对超类中的toString()方法中返回的原有信息进行覆盖。

    来讨论一个具体例子。假设程序中需要验证用户输入的表示年龄的数据必须是正整数值。我们可以按照以上模式编写这个自定义异常类如下:

     

    public classNegativeAgeException extends Exception {

                                                //或者:extends Throwable

        public NegativeAgeException()  {}

        public NegativeAgeException(String message){

            super(message);

        }

    }

     

    下面是应用这个自定义异常类的例子:

     try{

       String ageString = JOptionPane.showInputDialog("Enteryour age: ");

       if (Integer.parseInt(ageString) < 0)

            throw newNegativeAgeException("Please enter a positive age");

       else

            JOptionPane.showMessageDialog(null,ageString, "Age", 1);

    }

    catch(NegativeAgeExceptione){

        System.out.println(e);

    }

    ...

     

    或者,可以创建一个缺省对象,然后在catch中打印具体信息,如:

     

    throw newNegativeAgeException();

        ...

    catch(NegativeAgeException e) {

        System.out.println("Please enter apositive age");

     将产生与第一个例子相同的效果。

     

    自定义异常处理

    无论是利用标准API异常类来处理特殊的异常,或者编写自定义的异常类来达到同样目的,问题的关键是:当这个异常发生时,如何及时捕获这个异常。捕获这个异常后,如何产生精确的异常处理信息。

        毋庸置疑,我们不可能期待JVM自动抛出一个自定义异常,也不能够期待JVM会自动处理一个自定义异常。发现异常、抛出异常以及处理异常的工作必须靠编程人员在代码中利用异常处理机制自己完成。

    一般情况下,发现和抛出一个自定义异常通过在try程序块中利用if和throw语句完成,即:

    try {

        ...

        if (someExceptionConditon == true) {

            throw new CustomException("Acustom exception xxx occurred. Please

            check your entry...")

        ...

        }

    catch(CustomException e) {

        ...

    }

    而打印异常处理信息可以在抛出时包括在构造器的参数中,或者包括在处理这个异常的catch中。另外应该注意在自定义异常发生之前,有可能产生标准异常的情况。例如,在一个需要验证年龄必须是正整数值的程序中,利用自定义异常类,如NegativeAgeException,验证输入的年龄是否正整数,即:

     

    try {

        ...

        if (Integer.parseInt(ageString) <0)    

            throw NegativeAgeException("Pleaseenter a positive age");

        else

            ...

        }

        catch (NumberFormatException e) {

            System.out.println(e);

        }

        catch (NegativeAgeException e) {

            System.out.println(e);

        }

        ...

     

    注意在这个代码中,如果ageString是非法整数字符串,如“25ab”,系统将首先抛出NumberFormatException,而不会执行throw NegativeAgeException("Please enter apositive age")。所以应该在catch中加入对NumberFormatException的处理。

    本文出自 “海外咖啡豆 - 高永强的博客天地”博客,请务必保留此出处http://yqgao.blog.51cto.com/773490/174767

    转载于:https://www.cnblogs.com/kangsir/p/6653303.html

    展开全文
  • Java自定义异常类

    千次阅读 2016-10-27 09:11:46
    11.7.1 编写自定义异常类的模式 编写自定义异常类实际上是继承一个API标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下:   public class CustomException extends ...
  • 编写自定义异常类实际上是继承一个API标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下: public class CustomException extends Exception {//或者继承任何标准异常类 ...
  • Java编写简单的自定义异常类

    万次阅读 多人点赞 2017-12-29 19:19:07
    try catch是这之间所包含的代码如果出现异常时捕获他,并进行处理的,如果代码之间有错误,不会影响程序继续执行下去,程序会继续往后执行。 2:throw 是在程序中明确抛出引发的异常,比如throw new Exception(); 3...
  • 创建用户自定义异常类GoBangException,该类继承自Exception父类,在该类定义一个无参的构造器和一个String类型形参的构造器,在该构造器调用父类有参构造器,并将该构造器中的String类型参数,传递给父类构造器。...
  • Java 自定义异常类

    2016-04-18 14:41:02
    11.7.1 编写自定义异常类的模式 编写自定义异常类实际上是继承一个API标准异常类,用新定义的异常处理信息覆盖原有信息的过程。常用的编写自定义异常类的模式如下:   public class CustomException extends ...
  • JAVA 自定义异常类

    千次阅读 2018-06-08 17:53:15
    自定义异常类 在编写程序时可以扩展Exception类定义自己的异常类,然后根据程序的需要来规定哪些方法产生这样的异常。个方法在声明时可使用throws关键宇声明要产生的若干个异常,并在该方法中具体给出产生异常的...
  • 1.编写一个货物Goods 有一个布尔型属性 isDanger有一个字符串型属性 name分别对这两个属性设置set get方法 2、编写一个Exception的子类DangerException。有一个toShow()方法输出“属于危险品”,无需返回。 3、...
  • java--自定义异常类

    2019-11-29 17:11:25
    (2)掌握自定义异常类的语法。 (3)掌握自定义异常类的使用。 实验内容 (1)编写DivideZeroException类处理除零异常并进行测试。 (2)掌握异常的捕获、常用的异常处理。 (3)学会如何自定义异常类。 实验...
  • Java自定义异常类

    2017-02-19 22:55:20
    为什么要自己编写异常类?假如jdk里面没有提供的异常,我们就要自己写。我们常用的类ArithmeticException,NullPointerException,NegativeArraySizeException,ArrayIndexoutofBoundsException,SecurityException...
  • 编写内容之前,先简单介绍一下java的异常,异常分为两大类,运行时异常(RuntimeException)和除了运行时异常之外的其他异常(编译时异常)。好多程序猿在异常的处理上都是比较模糊...自定义异常类:BaseException:pu...
  • Java自定义异常

    2018-08-15 12:31:07
    自定义文件名不合法异常类 public class FileNameException extends RuntimeException{ public FileNameException(String message) { ... * function:编写一个自定义异常。 author:wangpeng time:2018年...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 321
精华内容 128
关键字:

java编写自定义异常类

java 订阅