11.异常（三）

荒诞硬汉

于 2022-04-16 17:25:02 发布

阅读量440

点赞数

文章标签： java

本文链接：https://blog.csdn.net/zyhhkb/article/details/124213064

版权

5.throws关键字

在程序执行的过程中往往涉及不同类中方法的调用，为了方便调用者进行异常处理，往往通过关键字throws在这些方法声明时对可能产生的异常进行标记。

范例：观察throws关键字的使用

package cn.kuiba.util;

class MyMath{
    /*
    * 定义数学除法计算，该执行时可能会产生异常
    * @param x 除数
    * @param y 被除数
    * @return 除法计算结果
    * @throws Exception 计算过程中产生的异常，可以是具体异常类型也可以简化使用Exception
    */
    public static int div(int x,int y)throws Exception{
        return x/y;
    }
}
public class Main {
    public static void main(String[] args){
        try {                           //调用throws方法时需要进行异常处理
            System.out.println(MyMath.div(10,2));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

执行结果

本程序在主类中调用MyMath.div(10,2)方法实现了除法操作，由于此方法上使用throws抛出了异常，这样在调用此方法时就必须明确使用异常处理语句处理该语句可能发生的异常。

主方法本身也属于一个Java中的方法，所以如果在主方法中使用了throws关键字，就表示在主方法里可以不用强制性地进行异常处理。如果出现了异常，将交给JVM默认处理，则此时会导致程序中断执行。

范例：在主方法中继续抛出异常

package cn.kuiba.util;

class MyMath{
    /*
     * 定义数学除法计算，该执行时可能会产生异常
     * @param x 除数
     * @param y 被除数
     * @return 除法计算结果
     * @throws Exception 计算过程中产生的异常，可以是具体异常类型也可以简化使用Exception
     */
    public static int div(int x,int y)throws Exception{
        return x/y;
    }
}
public class Main {
//在主方法中使用throws继续抛出可能产生的异常，一旦出现异常则交由JVM进行默认异常处理
    public static void main(String[] args)throws Exception{
        try {
            System.out.println(MyMath.div(10,2));
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(MyMath.div(10,0));
    }
}

执行结果

5
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at cn.kuiba.util.MyMath.div(Main.java:12)
	at cn.kuiba.util.Main.main(Main.java:22)

本程序在主方法上使用throws抛出异常，这样当代码出现异常时，由于主方法没有编写相应的异常处理语句，所以最终会交给JVM默认进行处理。在实际的项目开发中，主方法往往是作为程序的起点存在，所有异常应该在主方法中全部处理完成，不应该向上抛出。

6.throw关键字

在默认情况下，所有异常类的实例化对象都会由JVM默认实例化并且自动抛出。为了方便用户进行异常抛出，有JVM提供throw关键字。

范例：手动异常抛出

package cn.kuiba.util;

public class Main {
    public static void main(String[] args){
        try {                        //异常对象不再由系统生成，由手动实例化
            throw new Exception("自己抛着玩的对象。");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

执行结果

java.lang.Exception: 自己抛着玩的对象。
	at cn.kuiba.util.Main.main(Main.java:6)

本程序通过throw关键字并利用Exception类的构造方法实例化了一个异常对象，所以为了保证程序正确执行就必须进行此异常对象的捕获与处理。

提示：throw与throws关键字的区别

throw：是在代码块中使用的，主要是手动进行异常对象的抛出。
throws：是在方法定义中使用，表示将此方法中可能产生的异常明确告诉给调用处，由调用处进行处理。

7.异常处理模型

本节将综合使用try、catch、finally、throw、throws这些异常处理关键字，结合案例分析项目开发时如何有效进行异常处理。

现在假设要定义一个可以实现除法计算的方法，在这个方法中开发要求如下：

在进行数学计算开始与结束的时候进行信息提示。
如果在进行计算的过程中产生了异常，则要交给调用来处理。

范例：实现合理的异常处理

package cn.kuiba.util;

class MyMath{
    public static int div(int x,int y)throws Exception{             //异常抛出
        int temp=0;
        System.out.println("***【START】除法计算开始***");              //开始提示信息
        try {
            temp=x/y;                                                //除法计算
        }catch (Exception e){
            throw e;                                                 //抛出捕获到的异常对象
        }finally {
            System.out.println("***【END】除法计算结束***");            //结束提示信息
        }
        return temp;                                                 //返回计算结果
    }
}
public class Main {
    public static void main(String[] args){
        try {
            System.out.println(MyMath.div(10,0));               //调用计算方法
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

执行结果

***【START】除法计算开始***
***【END】除法计算结束***
java.lang.ArithmeticException: / by zero
	at cn.kuiba.util.MyMath.div(Main.java:8)
	at cn.kuiba.util.Main.main(Main.java:20)

本程序利用几个异常处理关键字实现了一个标准的异常处理流程，在div()方法中不管是否产生异常都会按照既定的结构执行，并且会将产生的异常交由调用处来进行处理。

以上是标准处理结构，实质上catch语句里除了简单地抛出异常对象外，也可以进行一些简单的异常处理。但如果此时的代码确定不再需要本程序做任何的异常处理，也可以直接使用try...finally结构捕获执行finally代码后直接抛出。

范例：使用简化异常模型

package cn.kuiba.util;

class MyMath{
    public static int div(int x,int y)throws Exception{            //异常抛出
        int temp=0;
        System.out.println("***【START】除法计算开始***");            //开始提示信息
        try {
            temp=x/y;                                                //除法计算
        }finally {
            System.out.println("***【END】除法计算结束***");        //结束提示信息
        }
        return temp;                                               //返回计算结果
    }
}
public class Main {
    public static void main(String args[]){
        try {
            System.out.println(MyMath.div(10,0));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

本程序取消了catch语句，这样的话一旦产生异常，在执行完finally语句后，由于没有任何的异常处理语句，所以会将异常直接通过方法声明throws交给调用处进行处理。

8.RuntimeException

在Java里为了方便用户代码编写，提供了RuntimeException类，这种异常类的最大特征在于：程序在编译时不会强制性的要求用户处理异常，可以选择性处理。但如果没有处理又发生了异常，将交给JVM默认处理，即RuntimeException的子异常类可以由用户根据需要选择性处理。所有的RuntimeException子类对象都可以根据用户的需要进行选择性处理，所以调用时不处理也不会有任何的编译语法错误，这样可以使得程序开发变得更加灵活。

范例：使用parselnt()方法不处理异常

package cn.kuiba.util;

public class Main {
    public static void main(String args[]){
        int num=Integer.parseInt("123");
        System.out.println(num);
    }
}

本程序没有处理parseInt()异常，正常输出，若出现异常，将将交由JVM进行默认处理。（若要将字符串转变为int数据类型，那么可以利用Integer类进行处理，因为在Integer类定义了如下方法。字符串转换int：public static int parseInt(String s)throws NumberFormateException。此时，parseInt()方法抛出了NumberFormateException，而这个异常类就属于RuntimeException子类。

提示：RuntimeException和Exception的区别

RuntimeException是Exception的子类。
Exception定义了必须处理的异常，而RuntimeException定义的异常可以选择性地处理。
常见的RuntimeException：NumberFormatException、ClassCastException、NullPointerException、ArithmeticException、ArrayIndexOutOfBoundException。

9.自定义异常类

在我们执行数据增加操作时，可能会出现一些错误，而这些错误一旦出现就应该抛出异常（如BombException），但这样的异常Java并没有，所以需要用户自己定义异常类。要想自定义异常类，只需要继承Exception(强制性异常处理)或RuntimeException(选择性异常处理)父类即可。

范例：实现自定义异常

package cn.kuiba.util;

class BombException extends Exception{              //自定义强制处理异常
    public BombException(String msg){
        super(msg);                                 //调用父类构造
    }
}
class Food{
    public static void eat(int num)throws BombException{
        if (num>9999){
            throw new BombException("米饭吃太多了，肚子爆了。");
        }else {
            System.out.println("正常吃，正舒服。");
        }
    }
}
public class Main {
    public static void main(String args[]){
        try {
            Food.eat(11);                       //传入要吃的数量
        }catch (BombException e){
            e.printStackTrace();
        }
    }
}

执行结果

正常吃，正舒服。

本程序设计了一个自定义的异常类型，当条件满足会自动抛出。

10.assert关键字

assert关键字在JDK1.4后传入，主要功能是进行断言。断言是指程序执行到某行之后，其结果一定是预期的结果。

范例：观察断言的使用

package cn.kuiba.util;

public class Main {
    public static void main(String args[])throws Exception{
        int x=10;
        assert x==100:"x的内容不是100";
        System.out.println(x);
    }
}

本程序中使用了断言进行操作，很明显断言判断条件不满足，但没有错误产生，这是因为Java默认情况下不开启断言。如果想要启用断言，应该增加一些选项。

java -ea cn.kuiba.util.Main

而增加了“-ea”参数后，就会出现错误信息。

Exception in thread "main" java.lang.AssertionError: x的内容不是100
	at cn.kuiba.util.Main.main(Main.java:6)

荒诞硬汉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
11.异常（三）

5.throws关键字在程序执行的过程中往往涉及不同类中方法的调用，为了方便调用者进行异常处理，往往通过关键字throws在这些方法声明时对可能产生的异常进行标记。范例：观察throws关键字的使用package cn.kuiba.util;class MyMath{ /* * 定义数学除法计算，该执行时可能会产生异常 * @param x 除数 * @param y 被除数 * @return 除法计算结果 * @throws Except
复制链接

扫一扫