异常(Exception)

Tweek_

已于 2023-03-30 22:45:12 修改

阅读量314

点赞数 1

分类专栏： JAVA基础文章标签： jvm java 开发语言

于 2023-03-29 10:31:26 首次发布

本文链接：https://blog.csdn.net/Tweek_/article/details/129831673

版权

JAVA基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、异常的定义

二、异常体系

三、异常的分类

1、编译期异常(CheckedException)

2、运行期异常(RuntimeException)

4、Throwable中3个处理异常的方法

一、异常的定义

异常(Exception)：程序在执行过程中出现了不正常的情况，异常会中断正在执行的程序，使得JVM非正常停止。

通俗来说，异常就是，在程序运行的过程中发生了与程序员预期不符事情，且该种事情并非在编译过程中出现的逻辑、语法错误。

二、异常体系

在Java中，异常本身就是一个类，所有的错误、异常都有一个共同的超类Throwable。

Throwable本身有两个重要的子类，分别是Exception与Error，前者是运行中的小错误，程序本身能处理，后者是严重的错误，程序本身无法处理，是JVM本身存在的错误。

下面是异常体系结构图：

三、异常的分类

异常主要分为两种，编译期异常、运行期异常

1、编译期异常(CheckedException)

必须显示处理，否则程序就会发生错误，无法通过编译

此类异常是Exception类及其子类

下面是代码示例：

public class ExceptionDemo {
    public static void main(String[] args) {
        // method();
        method2();
    }

    private static void method2() {
        /**
            编译时异常，有可能出现异常，需要抛出异常，此时控制台显示java: 未报告的异常错误java.text.ParseException; 必须对其进行捕获或声明以便抛出。故此时的解决方法是try..catch处理。
          */
        String s="2023-3-28";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d =sdf.parse(s);
        System.out.println(d);

    }
}

2、运行期异常(RuntimeException)

无需显示处理，可以和编译期异常一样处理

此类异常是RuntimeException类及其子类

下面是代码示例：

/**
 * @author Tweek
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        method();
    }

    private static void method() {
        //运行期异常
        int[] arr={1,2,3};
        System.out.println(arr[3]); //控制台显示ArrayIndexOutOfBoundsException 
    }
}

四、异常处理机制

当出现异常的时候，我们需要来自己处理异常。

java异常处理的五个关键字:try、catch、finally、throw、throws

1、try-catch

在Java中，我们使用try-catch捕获并处理异常

try-catch语句格式示例：

try {
            //包含可能发生异常的语句
            /* 当 try 部分抛出了异常对象时，将立刻结束执行，转而执行
            相应的 catch 部分 */
        }
        catch (ExceptionSubClass1  e) {
            //当产生ExceptionSubClass1型异常时的处理措施
        }
        catch (ExceptionSubClass2  e) {
            //当产生ExceptionSubClass2型异常时的处理措施
        }
        finally {
            //无论是否发生异常，都无条件执行的语句
        }
    }

下面代码示例，能让我们更好地理解：

编译期异常

/**
 * @author Tweek
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        // method();
        method2();
    }

    private static void method2() {
        //编译时异常
      try {
          String s = "2023-3-28";
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date d = sdf.parse(s);
          System.out.println(d);
      }
      catch(ParseException e){
          e.printStackTrace(); //出现异常时的处理方法
      }
    }
}

控制台输出：
Tue Mar 28 00:00:00 CST 2023

运行期异常

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();//抛出异常，程序不中断
        System.out.println("结束");
       // method2();
    }
  
private static void method() {
        //运行期异常
       try{ int[] arr={1,2,3};
        System.out.println(arr[3]); //ArrayIndexOutOfBoundsException
    }catch (ArrayIndexOutOfBoundsException e){
           System.out.println("你访问的数组索引不存在");
       }
    }
}

控制台输出：
开始
你访问的数组索引不存在
结束

2、声明异常throws关键字

throws：将异常标识处理，并将其报告给调用者。该方法只声明异常不处理异常，提醒调用者来处理该异常

下面是代码示例：

运行期异常

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
       // method2();
    }
    
    private static void method() throws ArrayIndexOutOfBoundsException {
        //运行期异常
        int[] arr={1,2,3};
        System.out.println(arr[3]); //ArrayIndexOutOfBoundsException

    }
}

//由输出可知，throws仅标识异常，提醒调用者，然而并没有处理异常，使得程序中断。
控制台输出：
开始
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
    at mException.itemout.Excp.ExceptionDemo.method(ExceptionDemo.java:35)
    at mException.itemout.Excp.ExceptionDemo.main(ExceptionDemo.java:14)

编译期异常

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        try {
            method2();
        } catch (ParseException e) {
           // throw new RuntimeException(e);
            e.printStackTrace();
        }
        System.out.println("结束");
        //method();
    }
    /**
   在标识问题后，在主函数处调用method方法出现异常有两个解决方法：
    1、继续在主函数出用关键字throws标识异常ParseException，因为可能会出现错误的parse方法在合理的参数匹配下并未出现错误。
    2、用try-catch捕获ParseException异常并处理异常使得程序能继续运行不中断
*/

    private static void method2() throws ParseException{
        //编译时异常
          String s = "2023-3-28";
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date d = sdf.parse(s);
          System.out.println(d);

    }
}

控制台输出：
开始
Tue Mar 28 00:00:00 CST 2023
结束

3、抛出异常throw

throw关键字：使用throw关键字在指定的方法中抛出指定的异常

使用格式：throw new Exception(异常产生的原因)

注意：

1、throw关键字必须写在方法内部

2、throw关键字后面new的对象必须是Exception或Exception的子类对象

3、若throw关键字后边创建的是RuntimeException或其子类对象，我们可以不处理，交给JVM处理。(打印异常对象，并中断程序)

4、若throw关键字后边创建的对象是编译异常(写代码的时候报错)，我们必须处理该异常，使用throws或try-catch

下面为代码示例：

/**
 * @author Tweek
 */
public class ExceptionTest {
    /**
     * 此测试类显示throw的主要用途
     *
     * @param args
     */
    public static void main(String[] args) {

        int[] arr =null;
        /**
         * 首先必须对传递的参数进行合法性校验
         */
        getElement(arr,0);
    }

    private static int getElement(int[] arr,int index) {
        /**
         * 我们可以对传递过来的参数数组进行合法性校验
         * 如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题
         *          * 如若数组为null则抛出空指针异常NullPointerException-->RuntimeException的子类
         */
       if(arr == null){
           throw new NullPointerException("传递的数组指为null");
       }
        /**
         * 我们也可以对传递过来的index参数进行合法性校验
         */
        if(index<0 || index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }
       int ele = arr[index];
       return ele;
    }
}

控制台输出：
Exception in thread "main" java.lang.NullPointerException: 传递的数组指为null
    at mException.itemout.Excp.ExceptionTest.getElement(ExceptionTest.java:22)
    at mException.itemout.Excp.ExceptionTest.main(ExceptionTest.java:14)

4、Throwable中3个处理异常的方法

(1)printStackTrace() 方法

指出异常的类型、性质、栈层次及出现在程序中的位置。JVM打印异常对象，默认此方法异常信息是最全面的。

下面是代码示例：

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
        //method2();
    }


    private static void method() {
        //运行期异常
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); //ArrayIndexOutOfBoundsException
        }catch (ArrayIndexOutOfBoundsException e){
             e.printStackTrace();
        }
    }
}
控制台输出：
开始
结束
java.lang.ArrayIndexOutOfBoundsException: 3
    at mException.itemout.Excp.ExceptionDemo.method(ExceptionDemo.java:37)
    at mException.itemout.Excp.ExceptionDemo.main(ExceptionDemo.java:14)

(2)getMessage() 方法

输出错误的性质。返回此throwable的简短描述。

下面是代码示例：

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
        //method2();
    }


    private static void method() {
        //运行期异常
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); //ArrayIndexOutOfBoundsException
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e.getMessage());
        }
    }
}

控制台输出：
开始
3     //表示索引3 超出数组范围
结束

(3)toString() 方法

给出异常的类型与性质。返回throwable的详细消息字符串

下面是代码示例：

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
        //method2();
    }


    private static void method() {
        //运行期异常
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); //ArrayIndexOutOfBoundsException
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e.toString());
        }
    }
}

控制台输出：
开始
java.lang.ArrayIndexOutOfBoundsException: 3
结束

5、finally代码块

(1)finally

有些特定的代码无论异常(此类异常指的是程序代码而非finally代码块中的代码)是否发生都要执行，所以存放在finally中的代码块是一定会被执行的。像是在try语句块中打开了一些物力资源，在使用完后，最终关闭打开的资源。

(2)finally不会被执行的情况：

1.前面的代码中出现了 System.exit ()

2.finally 语句块中发生了异常

3.关闭CPU

（3）finally的格式

try..catch..finally

下面是代码示例：

try {
            //包含可能发生异常的语句
            /* 当 try 部分抛出了异常对象时，将立刻结束执行，转而执行
            相应的 catch 部分 */
        }
        catch (ExceptionSubClass1  e) {
            //当产生ExceptionSubClass1型异常时的处理措施
        }
        catch (ExceptionSubClass2  e) {
            //当产生ExceptionSubClass2型异常时的处理措施
        }
        finally {
            //无论是否发生异常，都无条件执行的语句
        }
    }

（4）finally的注意事项

1.finally不能单独使用，必须和try一起使用

2.finally一般用于资源释放(资源回收)，无论程序是否出现异常，最后都要资源释放

3、若finally中有return语句，永远返回finally中的结果，故尽量避免该情况。

6、多异常的捕获处理

(1)多个异常分别处理

/**
 * @author Tweek
 */
public class ExceptionTest2 {
    /**
     * 多个异常分别处理
     * @param args
     */
    public static void main(String[] args) {
        try{
            int[] arr ={1,2,3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }
        try{
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch(IndexOutOfBoundsException o){
            System.out.println(o);
        }
        System.out.println("结束");
    }
}

控制台输出：
java.lang.ArrayIndexOutOfBoundsException: 3
java.lang.IndexOutOfBoundsException: Index: 3, Size: 3
结束

(2)多个异常一次捕获，多次处理

public class ExceptionTest2 {
    /**
     * 多个异常一次捕获，多次处理
     * @param args
     */
    public static void main(String[] args) {
        try{
            int[] arr ={1,2,3};
            System.out.println(arr[3]);
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch(IndexOutOfBoundsException o){
            System.out.println(o);
        }

        System.out.println("结束");
    }
}
/**
    此时捕获到数组越界异常即处理此异常，若无数组越界异常，有索引越界异常即进入下一个catch处理索引越界异常
*/
控制台输出：
java.lang.ArrayIndexOutOfBoundsException: 3
结束

注意事项：

catch里边定义的异常变量，如果有子父类继承关系，那么子类的异常变量必须写在父类上边，否则会报错。

如IndexOutBoundsException是ArrayIndexOutOfBoundsException的父类，即ArrayIndexOutOfBoundsException作为子类需在父类上边先被捕获。

(3)多个异常一次捕获一次处理

public class ExceptionTest2 {
    /**
     * 多个异常一次捕获一次处理
       前提是捕获的异常类型有子父类关系，然后catch采用父类对象，如IndexOutBoundsException与ArrayIndexOutOfBoundsException，在此情景中可只用父类IndexOutBoundsException对象作捕获。
       当然Exception也可以。
     * @param args
     */
    public static void main(String[] args) {
        try{
            int[] arr ={1,2,3};
            System.out.println(arr[3]);
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch(IndexOutOfBoundsException o){
            System.out.println(o);
        }

        System.out.println("结束");
    }
}

控制台输出：
java.lang.ArrayIndexOutOfBoundsException: 3
结束

五、子父类异常

1、如果父类方法抛出了多个异常，子类重写父类方法时，抛出与父类相同的异常或者是父类异常的子类或者不抛出异常。

2、父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理不能声明抛出

下面是代码示例：

/**
 * @author Tweek
 */
public class ExceptionTest3 {
    /**
     * 父类
     */
    public void show1() throws NullPointerException{}
    public void show2() throws IndexOutOfBoundsException{}
    public void show3() throws IndexOutOfBoundsException{}
    public void show4(){}
}
class Son extends ExceptionTest3{
    //子类重写父类方法时，找出和父类相同的异常

    @Override
    public void show1() throws NullPointerException {
        super.show1();
    }

    //子类重写父类方法时，找出父类异常的子类

    @Override
    public void show2() throws IndexOutOfBoundsException {
        super.show2();
    }

    //子类重写父类方法事，不抛出异常

    @Override
    public void show3() throws IndexOutOfBoundsException {
        super.show3();
    }

    //父类方法没有抛出异常，子类重写父类该方法时不可能抛出异常

    //public void show4() throws Exception {} //此处报错

    //父类方法没有抛出异常,子类产生异常只能捕获处理，不能声明异常

    @Override
    public void show4() {
        try{
            throw new Exception("编译期异常");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

六、自定义异常

1、概述

(1)自定义异常：当JDK中定义好的异常类不够我们使用的时候，我们可以根据具体的异常情况来自定义我们所需要的异常类。例如成绩负数异常。

(2)自定义异常类格式:

public class xxxEception extends Exception/RuntimeException{

        //添加一个空参数的构造方法
        //添加一个带异常信息String参数的构造方法

}

注意:

(1)自定义异常类名一般都是以Exception结尾，说明其是一个异常类

(2)自定义异常类，必须继承Exception或RuntimeException

2、例子

自定义注册异常，在我们平时注册账号输入账号名时可能会出现异常提示“该账号名已被注册”，在具体自定义异常中，我们该如去定义呢。

(1)继承Exception是编译期异常：

必须处理该异常，通过throws或try..catch处理

下面的代码示例，能让我们更好地理解自定义异常：

/**
 * @author Tweek
 */
public class RegisterException extends Exception {
    /**
     * 自定义注册异常
     */
    //添加一个空参构造方法
    public RegisterException(){
        super();
    }
    //添加一个带异常信息String参数的带参构造方法
    public RegisterException(String message) {
        super(message);
    }
}

public class RegisterExceptionTest {
    /**
     * 模拟注册操作，若注册的用户名已存在，则做出异常提示：该用户名已被注册
     */
    //用数组保存已经注册的用户名
    static String[] userNames = {"Tweek","Jim","Peter"};
    public static void main(String[] args)  {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入你的用户名：");
        String userName = in.nextLine();
        checkUserName(userName);
    }

    private static void checkUserName(String userName)  {
        //遍历数组并作比较
        for (String name : userNames) {
            if (name.equals(userName)){
                //用户名重复吗，则抛出异常
                try {
                    throw new RegisterException("该用户名以被注册");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return; //结束方法，否则方法继续运行，会使"恭喜您注册成功！"出现在处理异常后。
                }
            }
        }
        System.out.println("恭喜您注册成功！");
    }
}

第一次控制台输出：
请输入你的用户名：Biden
恭喜您注册成功！
第二次控制台输出：
请输入你的用户名：Tweek
mException.itemout.ExcpT.RegisterException: 该用户名以被注册
    at mException.itemout.ExcpT.RegisterExceptionTest.checkUserName(RegisterExceptionTest.java:27)
    at mException.itemout.ExcpT.RegisterExceptionTest.main(RegisterExceptionTest.java:18)

(2)继承RuntimeException是运行期异常

无需处理，交给虚拟机(进行中断处理)

下面的代码示例，能让我们更好地理解自定义异常：

/**
 * @author Tweek
 */
public class RegisterException extends RuntimeException {
    /**
     * 自定义注册异常
     */
    //添加一个空参构造方法
    public RegisterException(){
        super();
    }
    //添加一个带异常信息String参数的带参构造方法
    public RegisterException(String message) {
        super(message);
    }
}

public class RegisterExceptionTest2 {
    /**
     * 模拟注册操作，若注册的用户名已存在，则做出异常提示：该用户名已被注册
     */
    //用数组保存已经注册的用户名
    static String[] userNames = {"Tweek","Jim","Peter"};
    public static void main(String[] args)  {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入你的用户名：");
        String userName = in.nextLine();
        checkUserName(userName);
    }

    private static void checkUserName(String userName)  {
        //遍历数组并作比较
        for (String name : userNames) {
            if (name.equals(userName)){
                //用户名重复吗，则抛出异常
                    throw new RegisterException("该用户名以被注册");//运行期异常，无需处理，交给JVM进行程序中断
            }
        }
        System.out.println("恭喜您注册成功！");
    }
}

第一次控制台输出：
请输入你的用户名：Biden
恭喜您注册成功！
第二次控制台输出：
请输入你的用户名：Tweek
Exception in thread "main" mException.itemout.ExcpT.RegisterException: 该用户名以被注册
    at mException.itemout.ExcpT.RegisterExceptionTest2.checkUserName(RegisterExceptionTest2.java:26)
    at mException.itemout.ExcpT.RegisterExceptionTest2.main(RegisterExceptionTest2.java:18)