当前位置：首页 > news >正文

Java学习-异常抛出及自定义

news 来源：原创 2025/5/24 13:54:09

（一）抛出异常

异常就是程序出现的问题

eg:类型转换异常，字符串abc无法转换为数字，所以开发者将可能出现的问题使用一个异常对象封装，通过该对象告诉我们出现异常的地方

package com.ap;
/*认识yi'chang*/
public class Exception {
    public static void main(String args[]){
        Integer.valueOf("abc"); //字符串abc无法转换为数字
    }

}
//异常报错：

Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
   at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
   at java.base/java.lang.Integer.parseInt(Integer.java:668)
   at java.base/java.lang.Integer.valueOf(Integer.java:999)
   at com.ap.Exception.main(Exception.java:5)

其他可能异常：数组下标越界；整数除零；

（二）异常的体系

异常的抛出和处理：

异常的作用：

（三）自定义运行时异常

（1）定义一个异常类继承RuntimeException

(2)重写构造器

//自定义异常
package ExceptionRunTime;
//必须让这个类继承RuntimeException，才能成为一个运行时异常类
public class AgeRunTimeException extends RuntimeException{
    //设置有参构造器和无参构造器
    public AgeRunTimeException(){

    }

    public AgeRunTimeException(String message){
//        当你调用 super(message) 时，实际上是在调用父类（在自定义运行时异常的场景下，
//        父类通常是 RuntimeException）的带参构造方法，
//        把错误信息传递给父类。父类会将这个错误信息存储在异常对象里，方便后续在捕获异常时获取并处理
        super(message);
    }

}

（3）通过throw new 异常类（***）来创建异常对象并抛出（编译阶段不报错，提醒不强烈，运行时才可能会出现）

//测试异常
package com.ap;

import ExceptionRunTime.AgeRunTimeException;

/*自定义异常，以及异常的作用*/
public class ExceptionTest1 {
    public static void main(String[] args) {
        //保存一个合法年龄
        try {//上层可以捕获异常并打印异常
            saveAge(160);
        } catch (Exception e) {
           e.printStackTrace(); //e.printStackTrace(); 是 Java 中用于打印异常堆栈跟踪信息的方法调用
            System.out.println("底层代码报错");
        }

    }
    public static void saveAge(int age){
        if(age>0 && age<150){
            System.out.println("年龄合法，保存成功~~~~~~~");
        }
        else{
            throw new AgeRunTimeException("当前年龄不合法");
        }
    }

}

（四）自定义编译时异常

1.编译时异常程序的两种显示处理

package com.ap;

import java.text.SimpleDateFormat;
import java.util.Date;

/*认识 编译时异常*/
public class ExceptionTest2 {
//main方法时由JVM调用，所以JVM是main方法的最上层程序
    public static void main(String[] args) throws Exception {  //1.通过throws向上抛出异常
        //解析异常是典型的编译时异常
        //编译时异常（也被叫做受检查异常）要求在代码里显式地处理，不然代码就无法通过编译
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d=sdf.parse("2012-12-2 10:23:23");
    }

}

package com.ap;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*认识 编译时异常*/
public class ExceptionTest2 {
    public static void main(String[] args) {
        //解析异常是典型的编译时异常
        //编译时异常（也被叫做受检查异常）要求在代码里显式地处理，不然代码就无法通过编译
        try {
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d=sdf.parse("2012-12-2 10:23:23");
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

}

（1）定义一个异常类继承Exception

(2)重写构造器

package ExceptionRunTime;
//必须让这个类继承Exception，才能成为一个编译时异常类
public class AgeException extends Exception{
    //设置有参构造器和无参构造器
    public AgeException(){

    }

    public AgeException(String message){
//        当你调用 super(message) 时，实际上是在调用父类（在自定义运行时异常的场景下，
//        父类通常是 RuntimeException）的带参构造方法，
//        把错误信息传递给父类。父类会将这个错误信息存储在异常对象里，方便后续在捕获异常时获取并处理
        super(message);
    }

}

（3）通过throw new 异常类（***）来创建异常对象并抛出（编译阶段就报错，提醒强烈）

package com.ap;

import ExceptionRunTime.AgeException;
import ExceptionRunTime.AgeRunTimeException;

/*自定义异常，以及异常的作用*/
public class ExceptionTest1 {
    public static void main(String[] args) {
        //保存一个合法年龄
        try {//上层可以捕获异常并打印异常
            SaveAge2(160);
        } catch (Exception e) {
           e.printStackTrace(); //e.printStackTrace(); 是 Java 中用于打印异常堆栈跟踪信息的方法调用
            System.out.println("底层代码报错");
        }

    }
   
    //编译时异常，需要显示处理异常，throw抛出异常 或用throws在方法上抛出异常
    public static void SaveAge2(int age)throws AgeException{
        if(age>0 && age<150){
            System.out.println("年龄合法，保存成功~~~~~~~");
        }
        else{
            throw new AgeException("当前年龄不合法");
        }
    }

}

（五）异常捕获

1、异常处理的总结？在开发中异常的常见处理方式是：底层的异常抛出去给最外层，最外层集中捕获处理。

代码中常见的异常处理：层层外抛，在最外层通过try-catch捕获异常

package com.ap;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//层层外抛，在最外层通过try-catch捕获异常
public class CatchException {
    public static void main(String[] args) throws FileNotFoundException, ParseException {
        try {
            Test1();//在这里是最外层，捕获异常
        } catch (FileNotFoundException e) {
           e.printStackTrace();
            System.out.println("您要找的文件不存在");
        } catch (ParseException e) {
          e.printStackTrace();
            System.out.println("解析失败");
        }
    }
    public static void Test1()throws FileNotFoundException, ParseException {//编译时异常
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d=sdf.parse("2012-12-2 10:23:23");
        System.out.println(d);

        Test2();//层层调用（抛出的异常会传到这里） 使用Alt+回车 抛出异常
    }

    public static void Test2()throws FileNotFoundException {
        //读取文件
        InputStream is=new FileInputStream("D:/mweijc.png");

    }
}

PS：也可以不用区分具体是什么异常，直接抛出：Exception