Java基础二十五（异常处理）_在java中, try-catch-finally结构可嵌套使用。 (判断,3.0分)a. 对b. -优快云博客

本文链接：https://blog.youkuaiyun.com/skylineII/article/details/109728317

本文围绕Java异常展开，介绍了异常体系结构，包括Error和Exception，以及编译时和运行时异常。详细阐述了异常处理的抓抛模型，重点讲解了try - catch - finally和throws + 异常类型两种处理方式，还提及了finally的使用、方法重写时的异常规则及自定义异常，并给出异常处理练习示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、异常体系结构

java.lang.Throwable
java.lang.Error:一般不编写针对性的代码进行处理
Exception：可以进行异常的处理
编译时异常（checked）
IOException
FileNotFoundException
ClassNotFoundException
运行时异常（unchecked,RunTimeException）
NullPointerException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
InoutMismatchException
ArithmeticException

public class ExceptionTest {
    //****************************以下是编译时异常***********************************
//    @Test
//    public void test7(){
//        File file = new File("hello.txt");
//        FileInputStream fis = new FileInputStream(file);
//
//        int data = fis.read();
//        while (data != -1){
//            System.out.println((char)data);
//            data = fis.read();
//        }
//
//        fis.close();
//    }

    //****************************以下是运行时异常************************************
    //NullPointerException
    @Test
    public void test1(){
//        int[] arr = null;
//        System.out.println(arr[3]);

        String str = "abc";
        str = null;
        System.out.println(str.charAt(0));
    }

    //ArrayIndexOutOfBoundsException
    @Test
    public void test2(){
        int[] arr = new int[10];
        System.out.println(arr[12]);
    }

    //ClassCastException
    @Test
    public void test3(){
        Object obj = new Date();
        String str = (String)obj;
    }

    //NumberFormatException
    @Test
    public void test4(){
        String str = "123";
        str = "abc";
        int num = Integer.parseInt(str);
    }

    //InoutMismatchException
    @Test
    public void test5(){
        Scanner scanner = new Scanner(System.in);
        int score = scanner.nextInt();
        System.out.println(score);

        scanner.close();
    }

    //ArithmeticException
    @Test
    public void test6(){
        int a = 10;
        int b = 0;
        System.out.println(a / b);
    }



}

Error:

java虚拟机无法解决的严重问题。如：jvm系统内部错误、资源耗尽等严重情况。比如：StackOverflowError

public class ErrorTest {

    public static void main(String[] args) {
        //1. 栈溢出java.lang.StackOverflowError
//        main(args);

        //2.堆溢出java.lang.OutOfMemoryError
        Integer[] arr = new Integer[1024 * 1024 * 1024];
    }
}

异常的处理：抓抛模型

过程一、“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常的对象并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行。

关于异常对象的产生：①系统自动生成的异常对象
②手动生成一个异常对象，并抛出（throws）

过程二、“抓”：可以理解为异常处理方式：①try-catch-finally ②throws

二、异常处理的方式一：try-catch-finally的使用

try{
//可能出现异常的代码
}catch（异常类型1 变量名）{
//处理异常的方式1
}
catch（异常类型2 变量名）{
//处理异常的方式2
}
catch（异常类型3 变量名）{
//处理异常的方式3
}
。。。
finally{
//一定会执行的代码
}

说明：

1.finally是可选的。
2.使用try将可能出现异常代码包装起来，在执行过程中一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3.一旦try中的异常对象匹配到某一个catch时，就就进入catch中进行异常的处理。一旦处理完成，跳出当前的try-catch结构（在没有finally情况下），继续执行其后的代码
4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
catch中的异常类型如果满足父子类关系，则要求子类一定声明在父类的上面。否则报错。
5.常用的异常对象处理方式：①String getMessage（） ②printStackTrace
6.try结构中声明的变量，再出了try结构以后不能调用
7.try-catch-finally结构可以嵌套
注意1：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。相当于使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
注意2：开发中由于运行时异常比较常见，所以通常不针对运行时异常编写try-catch-finally。针对编译时异常，一定要考虑异常的处理。

public class ExceptionTest1 {

   @Test
   public void test1(){
       String str = "123";
       str = "abc";
//        int num = 0;
       try {
//            num = Integer.parseInt(str);
           int num = Integer.parseInt(str);
           System.out.println("hello-------1");
       }
//        catch (NullPointerException e){//异常处理不匹配
//            System.out.println("出现空指针异常了。。。");
//        }
       catch (NumberFormatException e){
//            System.out.println("出现数值转换异常了。。。");
           //String getMessage();
//            System.out.println(e.getMessage());//For input string: "abc"
           //printStackTrace()
           e.printStackTrace();
       }catch (Exception e){
           System.out.println("出现异常");
       }
//        System.out.println(num);
       System.out.println("hello-------2");
   }
}

try-catch-finally中finally的使用

1.finally是可选的
2.finally中声明的是一定会被执行的代码。即使catch中又出现了异常，try中有return语句，catch中有
3.像数据库连接、输入输出流、网络编程Socket等资源，jvm是不能自动的回收的，需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

public class FinallyTest {

    @Test
    public void test2(){
        FileInputStream fis = null;
        try {
            File file = new File("hello.txt");//相对当前工程下的路径
            fis = new FileInputStream(file);//①

            int data = fis.read();
            while (data != -1){
                System.out.println((char)data);
                data = fis.read();
            }

        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis != null)//当①没有创建成功时候，fis没有创建，不需要关闭
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testMethod(){
        int num = method();
        System.out.println(num);
    }

    public int method(){
        try{
            int[] arr = new int[10];
            System.out.println(arr[14]);
            return 1;
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            return 2;
        }finally {
            System.out.println("一定会被执行");
            return 3;
        }
    }

    @Test
    public void test1(){
        try{
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        }catch (ArithmeticException e){
//            e.printStackTrace();
            int[] arr = new int[10];
            System.out.println(arr[14]);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("最后执行的代码");
        }
    }
}

三、异常处理的方式二：throws + 异常运行

1."throws + 异常类型"写在方法的声明处。指明此方法执行时，可能抛出的异常类型。
一旦方法执行时出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常后边的代码不再执行。
2.体会：try-catch-finally：将异常处理掉了。
throws只是将异常抛给方法的调用者。并没有真正将异常处理掉。
3.开发中如何选择try-catch-finally还是使用throws
3.1如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着子类重写的方法中有异常，必须使用try-catch-finally方式处理。
3.2执行的方法a中，先后调用了另外的几个方法，这几个方法时递进关系执行的。我们建议这几个方法使用throws的方式处理。而执行方法a可以考虑使用try-catch-finally方式精心处理。

public class ExceptionTest2 {

    public static void main(String[] args) {

        try {
            method2();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }


    }

    public static void method3(){
        try {
            method2();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void method2() throws IOException {
        method1();
    }

    public static void method1() throws IOException, FileNotFoundException {
        FileInputStream fis = null;
        File file = new File("hello1.txt");//相对当前工程下的路径
        fis = new FileInputStream(file);//①

        int data = fis.read();
        while (data != -1){
            System.out.println((char)data);
            data = fis.read();
        }
        fis.close();
        System.out.println("判断是否执行");
    }
}

方法重写规则一：

子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

public class OverrideTest {

    public static void main(String[] args) {
        OverrideTest test = new OverrideTest();
        test.display(new SubClass());
    }

    public void display(SuperClass s){
        try {
            s.method();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class SuperClass{
    public void method() throws IOException{

    }
}

class SubClass extends SuperClass{
    public void method() throws FileNotFoundException {

    }
}

自定义异常

public class StudentTest {

    public static void main(String[] args) {
        try {
            Student s = new Student();
            s.regist(-1001);
            System.out.println(s);
        } catch (Exception e) {
//            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}

class Student{

    int id;

    public void regist(int id) throws Exception {
        if(id > 0){
            this.id = id;
        }else{
//            System.out.println("输入的数据非法");
            //手动抛出异常对象
//            throw new RuntimeException("输入的数据非法");
            throw new Exception("输入的数据非法");//自动生成throws Exception
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

异常处理练习

编写应用EcmDef.java，接受命令行的两个参数，要求不能输入负数，计算两数相除。
对数据类型不一致（NumberFormatException）、缺少命令行参数（ArrayIndexOutOfBoundsException、除0）及输入负数（EcDef 自定义异常）进行异常处理。
提示：
（1）在主类（EcDef）中定义异常方法（ecm）完成两数相除功能
（2）在main（）方法中使用异常处理语句进行异常处理
（3）在程序中，自定义对应输入负数的异常类（EcDef）
（4）运行时接受参数java EcDef 20 10 //args[0] = “20” args[1] = “10”
（5）Integer类的static方法parseInt（String s）将s转换成对应的int值
如：int a = Integer.parseInt(“314”);//a = 314

public class EcmDef {
    public static void main(String[] args) {
        try {
            //可能出现运行时异常
            int i = Integer.parseInt(args[0]);
            int j = Integer.parseInt(args[1]);

            //编译时异常
            int result = ecm(i, j);
        }catch(NumberFormatException e) {
//            e.printStackTrace();
            System.out.println("数据类型不一致");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("缺少命令行参数");
        }catch(ArithmeticException e){
            System.out.println("除0");
        }catch(EcDef e){
            System.out.println(e.getMessage());
        }

    }

    public static int ecm(int i, int j) throws EcDef{
        if(i < 0 || j < 0){
            throw new EcDef("分子或父母为负数！");
        }
        return i / j;
    }
}

//自定义异常类
public class EcDef extends Exception{

    static final long serialVersionUID = -338751642229948L;
    public EcDef(){

    }
    public EcDef(String msg){
        super(msg);
    }
}