Java异常深入理解 12章

~是小王吖~

已于 2022-04-05 16:24:36 修改

阅读量573

点赞数 1

分类专栏： idea Java 异常文章标签：开发语言 java 后端

于 2022-04-05 16:24:10 首次发布

本文链接：https://blog.csdn.net/sunblogy/article/details/123971517

版权

Java 同时被 3 个专栏收录

46 篇文章 0 订阅

订阅专栏

idea

35 篇文章 0 订阅

订阅专栏

异常

1 篇文章 0 订阅

订阅专栏

第十二章

异常 Exception

12.1 异常引入

分析下面代码，看看输出什么

public class Eception01 {
public static void main(String[] args) {
int sum1 = 10;
int sum2 = 0;
int result = sum1/sum2;
System.out.println("结果：" +result);
}
}

解析：

package com.xiaowang.exception;

/**
 * @Author 小王
 * @DATE: 2022/3/20
 */
public class Eception01 {
    public static void main(String[] args) {
        int sum1 = 10;
        int sum2 = 0;
        //1.当程序执行到 sum1/sum2 的时候。因为 sum2 = 0，所以就会抛出一个异常ArithmeticException（Arithmetic算术）
        //2.当异常抛出后，程序就不会往下面运行了，直接退出了，这样导致整个系统的健壮性就不好
        //3.为了使代码还能运行，可以用异常处理机制来解决，使其还能够继续运行
        //4.当一个程序员觉得某一段代码会有异常或者是问题的时候，可以使用 try-catch 异常处理机制来解决，从而保证健壮性
        //5. 选中代码块，按 ctrl + alt + t ，然后选择 try - catch
        //6.这样就算有异常，还是可以继续执行
        //int result = sum1/sum2;
        int result = 0;
        try {
            result = sum1/sum2;
        } catch (Exception e) {
            e.printStackTrace();//这里是将错误赋值给e对象，然后输出e对象，这里代码是可以修改的
            System.out.println("错误原因："+e.getMessage());//这是输出异常，同时可以输出你想要的
        }
        System.out.println("结果：" +result);
    }
}

输出：
java.lang.ArithmeticException: / by zero
	at com.xiaowang.exception.Eception01.main(Eception01.java:20)
错误原因：/ by zero
结果：0

快捷键：选中觉得有异常的代码块，然后按 ctrl + alt +t ，然后选择try - catch

12.2 异常概念

1、基本概念
Java语言中，将程序执行中发生的不正常情况称为 ”异常“ （开发过程中的语法错误和逻辑错误不是异常）

在这里插入图片描述

11.3 异常体系图！！

Throwable异常体系图
在这里插入图片描述
总结
编译异常：
①是出现在 java源文件中的
②编译器能够检查出来的，并且是必须要去做处理的异常，不然程序就编译不通过，就不能被运行

运行异常：
①是出现在字节码文件转向，内存中类加载运行中的；
②编译器检查不出来的异常，一般是编程时的逻辑异常，时程序员应该要去避免的异常
③对于运行时异常可以不做处理，因为不会影响编译，而且很普遍，要是每一个都去用try-catch处理，那么整个程序的可读性和运行效率就会产生很大影响
在这里插入图片描述
体系图制作步骤：

步骤1：先输入 Throwable 然后按 ctrl + b 去查看源代码，然后选中 Throwable ，右键，然后选中如下，就饿可以看见体系图
在这里插入图片描述
步骤2：

步骤3：

12.4 常见的运行时异常

12.4.1 NullPointerException

空指针异常：
当应用程序视图在需要对象的地方使用null时，抛出该异常，体系图：
在这里插入图片描述

案例：

public class NullPointerException_ {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length());//因为name的长度是空的，所以输出的时候，就会报错
    }
}
输出：
Exception in thread "main" java.lang.NullPointerException
	at com.xiaowang.exception.NullPointerException_.main(NullPointerException_.java:10)

12.4.2 ArithmeticException

算术异常
出现异常的运算条件的时候，就会抛出算术异常，体系图：

在这里插入图片描述

案例：

public class NullPointerException_ {
    public static void main(String[] args) {
        int num1 =10;
        int num2 = 0;
        System.out.println(num1/num2);//因为num2是分母，所以不能为0，所以要报算术异常
    }
}
输出：
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.xiaowang.exception.NullPointerException_.main(NullPointerException_.java:16)

12.4.3 ArrayIndexOutOfBoundsException

数组下标越界异常：
用非法索引访问数组时抛出的异常，如果索引为负或者大于等于数组长度大小，则该索引就为非法的索引，体系图

在这里插入图片描述

案例：

public class NullPointerException_ {
    public static void main(String[] args) {
        // ArrayIndexOutOfBoundsException 异常
    int [] arr1 = {1,2};
        for (int i = 0; i <=arr1.length ; i++) {
            //因为这个数组的长度为2，但是arr1.length前面加了=，所以i是要到3的，数组实际上没有那么多，所以就会抛出数组下标越界异常
            System.out.println(arr1[i]);
        }
    }
}
输出：
1
2
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
	at com.xiaowang.exception.NullPointerException_.main(NullPointerException_.java:22)

Process finished with exit code 1

12.4.4 ClassCastExcepton

类型转换异常：
当试图将对象强制转换为不是实例的子类时，就会抛出该异常，体系图：
在这里插入图片描述

案例：

public class NullPointerException_ {
    public static void main(String[] args) {
        A a = new B();//向上转型，a的编译类型 A，运行类型 B
        B b = (B) a;//向下转型，将a强制转换成B本子类对象，没问题
        C c = (C) a;//代码的意思是，将a强制转换成C本子类的对象，
        // 但是呢，此时的a编译类型已经是B了，B类与C类之间并没有任何关系，所以强制转会抛出异常
    }
}
class A{ }
class B extends A{ }
class C extends A{ }
输出：
Exception in thread "main" java.lang.ClassCastException: com.xiaowang.exception.B cannot be cast to com.xiaowang.exception.C
	at com.xiaowang.exception.NullPointerException_.main(NullPointerException_.java:28)

Process finished with exit code 1

NumberFormatException

数字格式不正确异常：
当应用程序试图将字符串转换成一种数值类型，单该字符串不能转换为适应格式时，就会抛出该异常，使用异常我们可以确保输入的是满足条件的数字

体系图：
在这里插入图片描述

案例：

public class NullPointerException_ {
    public static void main(String[] args) {
        String name2 = "小王";
        String name1 = "123456";
        //将String转换成int类型
        int num = Integer.parseInt(name1);
        System.out.println(num);//这是正确的，可以成功输出
        int num2 = Integer.parseInt(name2);
        System.out.println(num2);//这里的String转换成int不能有相应的格式去接收，所以就会报错
    }
}
输出：
123456
Exception in thread "main" java.lang.NumberFormatException: For input string: "小王"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.xiaowang.exception.NullPointerException_.main(NullPointerException_.java:36)

12.5 编译异常

基本介绍：
编译异常是在编译期间，被jvm机检查出来有问题的地方，这种是必须要去处理的异常，否则代码不能通过编译，就不能运行

在这里插入图片描述

11.6 异常练习题

请添加图片描述

12.7 异常处理

12.7.1 基本介绍

异常发生时，对异常作出的处理方式

12.7.2 异常处理方式

12.7.2.1 try - catch - finally

基本介绍：
程序员在代码中捕获发生的异常，自行处理

处理机制图：
在这里插入图片描述
处理异常说明：

1、Java提供try和catch块来处理异常，try用于包含可能出错的代码，catch块用于处理try块中发生的异常，可以根据需求，在程序中出现多个try…catch块

2、基本语法：
try{
//可疑的代码
//将出现异常的代码块生成对应的异常对象，然后传给catch块
}catch（异常对象）{
//对异常的处理
}finally{
//finally是可有可无的
}

注意细节：

1、如果发生异常了，则异常后面的代码不会执行，将直接进入catch块去做出处理

public class TryCatchDetail {
    public static void main(String[] args) {
        //快捷键 CTRL+ ALT + T
        //1、如果发生异常了，则异常后面的代码不会执行，将直接进入catch块去做出处理
        try {//觉得会发生异常，所以用try-catch语句包起来
            String str = "江仔";
            int a = Integer.parseInt(str);//纯字的字符串不能转换为int数字，所以会报错
            System.out.println("数字="+a);//如果没有错，那么这段话肯定会输出，有错就会被跳过
        } catch (NumberFormatException e) {
            System.out.println("异常信息= "+e.getMessage());
        }
        System.out.println("程序继续执行....");
    }
}
输出：
异常信息= For input string: "江仔"
程序继续执行....

2、如果异常没有发生，那么try代码块就会顺序执行，不会进入catch块中

public class TryCatchDetail {
    public static void main(String[] args) {
        //快捷键 CTRL+ ALT + T
       //2、如果异常没有发生，那么try代码块就会顺序执行，不会进入catch块中    
    try {//觉得会发生异常，所以用try-catch语句包起来
        String str = "123";
        int a = Integer.parseInt(str);//123字符串可以被转换格式为int
        System.out.println("数字="+a);//所以没有错，所以这句话就会被执行
    } catch (NumberFormatException e) {//因为try块中的语句没错，所以catch语句不会被执行
        System.out.println("异常信息= "+e.getMessage());
    }
        System.out.println("程序继续执行....");
}
}
输出：
数字=123
程序继续执行....

3、如果不管是否发生异常，都希望某一段代码能够被执行（比如：释放资源，关闭文件、关闭连接），那么将所要执行的代码放入finally块中

public class TryCatchDetail {
    public static void main(String[] args) {
        //快捷键 CTRL+ ALT + T
        //1、如果发生异常了，则异常后面的代码不会执行，将直接进入catch块去做出处理
        //2、如果异常没有发生，那么try代码块就会顺序执行，不会进入catch块中
        //3、如果不管是否发生异常，都希望某一段代码能够被执行（比如：释放资源，关闭文件、关闭连接），那么将所要执行的代码放入finally块中
        try {//觉得会发生异常，所以用try-catch语句包起来
            String str = "江仔";
            int a = Integer.parseInt(str);//纯字的字符串不能转换为int数字，所以会报错
            System.out.println("数字="+a);//如果没有错，那么这段话肯定会输出，有错就会被跳过
        } catch (NumberFormatException e) {
            System.out.println("异常信息= "+e.getMessage());
        }finally {//无论有没有异常都要发生
            System.out.println("有异常时的finally，不管发生什么都要执行的代码块放在finally中..");
    }
    try {//觉得会发生异常，所以用try-catch语句包起来
        String str1 = "123";
        int a = Integer.parseInt(str1);//123字符串可以被转换格式为int
        System.out.println("数字="+a);//所以没有错，所以这句话就会被执行
    } catch (NumberFormatException e) {//因为try块中的语句没错，所以catch语句不会被执行
        System.out.println("异常信息= "+e.getMessage());
    }finally {
        System.out.println("无异常时的finally，不管发生什么都要执行的代码块放在finally中..");
    }
        System.out.println("程序继续执行....");
}
}
输出：
异常信息= For input string: "江仔"
有异常时的finally，不管发生什么都要执行的代码块放在finally中..
数字=123
无异常时的finally，不管发生什么都要执行的代码块放在finally中..
程序继续执行....

4、一个try块可以有多个catch块，捕获不同异常的时候进行不同的业务处理，要求是：父类的异常在后，子类异常在前，比如（Exception 在后，NullPointException 在前），如果发生异常，只会匹配一个catch

public class TryCatchDetail02 {
    public static void main(String[] args) {
        //既然觉得有异常，那就去捕获，CTRL+ALT+T，选择try- catch
        //1.如果try语句块有多个异常
        //2.一个try块可以有多个catch块去捕获异常，做出相应的异常处理
        //3.但是，父类的catch块要写在子类catch块的后面
        try {
            Person person = new Person();
            person = null;
            person.getName();//肯定会报错空指针异常，NullPointException
            int n1 = 10;
            int n2 = 0;
            int result = n1 / n2;//因为n2为0，所以肯定会报错ArithmeticException
        } catch (NullPointerException e) {//专门用来捕获空指针异常的catch块
            System.out.println("NullPointerException异常信息：" + e.getMessage());
        } catch (ArithmeticException e) {//专门用来捕获算术异常的catch块
            System.out.println("ArithmeticException异常信息：" + e.getMessage());
        } catch (Exception e) {//这里同时相当于捕获了以上两个异常，因为它们都是Exception的子类
            System.out.println("异常信息：" + e.getMessage());
            //没有上面两个catch块，肯定只输出NullPointException异常，因为它在ArithmeticException上面，
            // 有NullPointException异常了后直接进入catch块，下面ArithmeticException不会被执行
        }finally {

        }
    }
}

class Person {
    private String name = "江仔";

    public String getName() {
        return name;
    }
}
输出：
NullPointerException异常信息：null
分析：
①虽然我们有两个异常，三个catch块，但是最后，异常只会去匹配一个catch块，具体匹配的一般是出现在前面的异常
②之所以父类要写在子类的后面，是因为父类本就可以包含所有的异常块，如果写在前面，那子类的catch块就没有任何意义了，已经被捕获了，所以就会报错吖

5、可以直接使用 try - finally 来配合使用，这种就相当于，不去捕获异常，因此程序也会被崩掉，通常应用在：执行一段代码，不管有没有异常，都必须要执行的某个业务

public class TryCatchDetail02 {
    public static void main(String[] args) {
        //既然觉得有异常，那就去捕获，CTRL+ALT+T，选择try- catch
        try {
            int n1 = 10;
            int n2 = 0;
            int result = n1 / n2;//因为n2为0，所以肯定会报错ArithmeticException
        }finally {
            System.out.println("不管发不发生，处不处理异常，我都要执行的操作");
        }
        System.out.println("程序继续...");//前面异常没有被catch处理，所以程序直接崩掉了，不会被执行
    }
}
输出：
不管发不发生，处不处理异常，我都要执行的操作
Exception in thread "main" java.lang.NullPointerException
	at com.xiaowang.tryCatch.TryCatchDetail02.main(TryCatchDetail02.java:18)

try - catch - finally 执行顺序：

① 如果没有发生异常，则执行try块中的所有语句，不执行catch块的语句，如果后面又finally块，则最后也要执行finally中的语句

② 如果出现异常，则try块中异常发生后，try块中剩下的语句不会被执行，将直接执行catch块中的语句，如果又finally，最后还需要执行finally中的语句

12.7.2.2 throws

基本介绍：
将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是JVM

处理机制图：
在这里插入图片描述

Throws异常说明：

1、如果一个方法（中的语句执行时），可能产生某种异常，但是并不能确定如何让处理这种异常，则此方法应显示地声明抛出异常。表明该方法将不对这些异常做处理，而由该方法的调用者负责处理

2、在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以时方法中产生的异常类型，也可以是它的父类

package com.xiaowang.throws_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Throws01 {
    public static void main(String[] args) {
    }
    public void f2() throws Exception{
        //创建一个文件流对象，可能会产生异常
        //1.鼠标移到红色下划线处可以看到是FileNotFoundException，这是一个编译异常，必须要做出处理
        //2.可以使用try - catch - finally去处理
        //3.可以使用throws，抛出异常,让调用f2方法的调用者（一般也是一个方法）去处理异常
        //4.throws后面的异常类型可以是方法中产生的异常类型，也可以是其父类，当然子类和父类选择一个即可
        FileInputStream file = new FileInputStream("d://aa.txt");
    }
    //5.throws后面也可以是一个 异常列表，也就是可以抛出多个异常，当然也可以用他们的父类 Exception
    public void f3() throws FileNotFoundException,NullPointerException {
        FileInputStream file = new FileInputStream("d://aa.txt");
    }
}

Throws异常处理的注意事项：
1、对于编译异常，程序中必须要进行处理，比如 try - catch 或者 throws

2、对于运行时异常，程序中如果没有哦做出处理，默认就是throws的方式处理，最终由JVM机去暴力处理

3、子类重写父类方法的时候，对于异常抛出的规定：子类所抛出的异常必须和父类的异常一致，或者是父类异常的子类，可以通过Diagrams查看异常父子关系
在这里插入图片描述
4、在throws过程中，如果由try - catch ，就相当于已经处理异常，就可以不必去使用throws（二选一）

总结：
①两种异常处理的方法，选择一种就可以，

②如果每一个方法都不处理，最终交给JVM机来处理的话，那么JVM机就会输出此异常，然后直接退出程序

③如果没有异常处理机制，那么默认是throws处理机制

12.7.2.3 自定义异常

基本介绍：
当程序中出现了某些“错误”，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己去设计异常类，用于描述该错误信息

自定义异常步骤：
1、定义类：自定义异常类名（程序员自己写）继承Exception或者RuntimeEception
2、如果继承Exception，就属于编译异常
3、如果继承RuntimeException，就属于运行异常（一般来说，继承RuntimeException）

应用实例：
当我们接收Person对象年龄时，要求范围在18-120之间，否则抛出一个自定义异常（要求继承RuntimeException），并给出提示信息

/*当我们接收Person对象年龄时，要求范围在18-120之间，
 否则抛出一个自定义异常（要求继承RuntimeException），并给出提示信息*/
public class CustomException {
    public static void main(String[] args) {
        int age = 121;
        if (!(age >=18 && age<=120)){//throw手动的去扔出一个异常，后面是通过构造器实例化一个异常对象去判断
            throw new AgeException("年龄需要在18-120之间");
        }
        System.out.println("年龄范围正确");
    }
}
/*思路：
1.定义AgeException类去继承RuntimeException
2.给异常类创建一个构造器
3.在调用的时候通过设置构造器去判断*/
/*1.一般情况下自定义异常都是制作成运行时异常，好处就是可以使用默认处理机制*/
class AgeException extends RuntimeException{//定义一个异常类，继承RuntimeException
    public AgeException(String message){//构造器
        super(message);
    }
}

在这里插入图片描述

12.7.2.4 throw和throws区别

throws：
意义：异常处理的一种方式，位置：放在声明方法处，后面跟的是异常类型

throw：
意义：手动生成异常对象的关键字，位置：方法体中，后面跟的是异常对象

throw案例：
分析下列代码的输出

package com.xiaowang.throw_;

/**
 * @Author 小王
 * @DATE: 2022/3/22
 */
public class ThrowException {
    public static void main(String[] args) {
        try {
            ReturnExceptionDemo.methodA();//调用A方法，接收到返回的异常，所以传给下面e对象
        } catch (Exception e) {
            System.out.println(e.getMessage());//4.输出异常信息“制造异常”
        }
        ReturnExceptionDemo.methodB();//调用B方法
    }
}
class ReturnExceptionDemo{
    static void methodA(){
        try {
            System.out.println("进入A方法");//1.正常输出
            throw new RuntimeException("制造异常");//创建一个异常，但是因为有finally，所以不会立即返回
            //3.当finally块执行完毕后再返回，
        } finally {
            System.out.println("调用A方法的finally方法");//2.finally块必须要输出
        }
    }
    static void methodB(){
        try {
            System.out.println("进入B方法");//4.没有错误，但是还是得再finally后面返回，返回“进入B方法”
            return;//
        } finally {
            System.out.println("调用B方法的finally方法");//5.输出finally
        }
    }
}
输出：
进入A方法
调用A方法的finally方法
制造异常
进入B方法
调用B方法的finally方法

12.8 练习题

12.8.1 try - catch 练习题

A01：分析下列代码

package com.xiaowang.tryCatch;

import com.xiaowang.exception.NullPointerException_;
public class Exercise01 {
    public static int method() {
        try {
            String[] names = new String[3];//字符串长度为3的数组
            //数组对象没有实例化，所以，每个数组对象都是null
            if (names[1].equals("tong")) {//因为数组对象是null，所以为出现NullPointerException
                System.out.println(names[1]);
            } else {
                names[3] = "jack";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//那么就会执行这句catch语句块
            return 3;//3就会被返回
        } finally {//但是呢，有finally语句块，所以 4 是必须要被返回的
            return 4;
        }
    }
    public static void main(String[] args) {
        System.out.println(method());//所以最后被返回来的肯定是finally块的 4 ，如果没有finally块，肯定就输出3
    }
}
输出：
4

A02:分析下列代码：

public class Exercise02 {
    public static int method() {
        int i = 1;
        try {
            i++;//++在后，先用再加 i =1+1 = 2
            String[] names = new String[3];//字符串长度为3的数组
            //数组对象没有实例化，所以，每个数组对象都是null
            if (names[1].equals("tong")) {//因为数组对象是null，所以为出现NullPointerException
                System.out.println(names[1]);
            } else {
                names[3] = "jack";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//那么就会执行这句catch语句块
            return ++i;//++在前，先加再用，此时 i = 2+1 = 3
        } finally {//但是呢，有finally语句块，是必须要被返回的
            return ++i;//必须要返回的，i = 3+1 = 4
        }
    }
    public static void main(String[] args) {
        System.out.println(method());//所以最后被返回来的肯定是finally块的 4 ，如果没有finally块，肯定就输出3
    }
}
输出：
4

A03:分析下列代码

public class Exercise03 {
    public static int method() {
        int i = 1;
        try {
            i++;//++在后，先用再加 i =1+1 = 2
            String[] names = new String[3];//字符串长度为3的数组
            //数组对象没有实例化，所以，每个数组对象都是null
            if (names[1].equals("tong")) {//因为数组对象是null，所以为出现NullPointerException
                System.out.println(names[1]);
            } else {
                names[3] = "jack";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//那么就会执行这句catch语句块
            return ++i;//++在前，先加再用，此时 i = 2+1 = 3，因为下面的finally没有返回语句，
            // 所以此时i=3就被返回回去给了main方法中，但是不是立即返回，此时会出现临时变量temp =3
        } finally {//但是呢，有finally语句块，是必须要执行的
            ++i;// 相当于就是 临时变量temp+1 = 4
            System.out.println("i = "+ i);//finally是必须要执行的，所以这句话也是必须要输出的
        }//只有当finally执行过后，才会返回catch块的值，然后结束catch块的异常处理
    }
    public static void main(String[] args) {
        System.out.println(method());//此时接收到要输出3，但是呢，
        // 只有当finally执行过后，才会返回catch块的值，// 然后结束catch块的异常处理
    }
}
输出：
i = 4
3
特别注意：当finally中没有返回值的时候，前面catch块中的返回值不能立即返回，
会先赋值给一个临时变量，等finally结束后再返回

A04：
要求用户输入一个整数，如果用户输入的不是一个整数，就反复提示他输入整数，直到输入正确为止

package com.xiaowang.tryCatch;

import java.util.Scanner;
//如果一个用户输入的不是一个整数，就反复提示他输入整数，直到输入正确为止
public class exercise04 {
    public static void main(String[] args) {
        //思路
        // 1、创建Scanner对象，定义一个变量来存放接收的值
        //2、使用无限循环去接收输入（while）
        //3、然后将输入的值去转换成int
        //4、如果转换的时候发生错误，就会抛出异常，那么说明所输入的不是一个可以转成int的内容
        //5、如果没有抛出异常，那么就break，退出循环
        Scanner scanner = new Scanner(System.in);//创建Scanner对象
        int num = 0;//定义一个变量来存放接收的值
        while (true){
            System.out.println("请输入一个整数");
            try {
                num = Integer.parseInt(scanner.next());//这里是将输入的转换成int类型，scanner.next()输入的内容，不管格式
                break;//要是可以被转换成int，那么说明输入的正确，就跳出循环
            } catch (NumberFormatException e) {//要是输入的不可以转换成int，就会抛出异常
                System.out.println("你输入的不是一个整数");//因为无限循环，所以异常抛出后，继续去执行while里面的语句
            }
        }
        System.out.println("输入的值是："+num);
    }
}
输出：
请输入一个整数
小王
你输入的不是一个整数
请输入一个整数
sdfasf
你输入的不是一个整数
请输入一个整数
123
输入的值是：123

12.8.2 总练习题

在这里插入图片描述

package com.xiaowang.homework_;

/**
 * @Author 小王
 * @DATE: 2022/3/22
 */
public class Homework01 {
    public static void main(String[] args){//因为这里传入的是字符串的数组，所以需要将传入的参数进行int格式化
        /*int n1,n2;*/
        try {
            //2.缺少命令行参数异常，就是确保输入的字符串数组的长度是正确的，
            if (args.length !=2){//因为要输入两个参数，所以不能多也不能少
                throw new ArrayIndexOutOfBoundsException("参数个数不正确");//手动抛出异常
            }
            //1.在这里数据类型转换的时候，可能会发生异常
            //这一步验证要写在判断数组长度后面，不然的话，就已经先有了n1，n2两个数据，对数组长度的判断有影响
            int n1=Integer.parseInt(args[0]);
            int n2=Integer.parseInt(args[1]);
            //3.确保分母不为0
            double result = cal(n1,n2);
            //4.如果没有异常，那么就输出值
            System.out.println(result);
        } catch (NumberFormatException e) {
            System.out.println("参数输入格式不正确，必须是整数");
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e.getMessage());//输出异常信息
        }
    }
    //编写cal方法,static修饰，可以直接被调用
    public static double cal(int n1,int n2){
            return n1/n2;
    }
}

注：
这个题是直接利用了main方法的数组来进行验证的，相当于要去配置参数信息，方法如下：
在这里插入图片描述

A02:判断下列代码的输出：

public class Homework02 {
    public static void fun(){
        try {
            throw new RuntimeException();//抛出一个运算类型的异常，在finally执行后返回
        } finally {
            System.out.println("B");//1.执行finally，输出B
        }
    }

    public static void main(String[] args) {
        try {
            fun();//调用fun方法，发现调用的fun方法有异常，所以直接进入catch去处理
            System.out.println("A");//不会被执行
        } catch (Exception e) {
            System.out.println("C");//2.输出catch块处理方法
        }
        System.out.println("D");//3.输出D
    }
}
输出：
B
C
D

A03：说出下列代码是否会发生异常，如果会，是哪种异常，如果不会，则打印结果是什么：？注：和A01一样去配置验证

public class Homework03 {
    public static void main(String[] args) {
        if (args[4].equals("john")){
            //如果args数组没有值，那么就会ArrayIndexOutOfBoundsException
            //也可能会发生NullPointException异常
            System.out.println("AA");
        }else {
            System.out.println("BB");
        }
        Object o = args[2];//没问题
        Integer i = (Integer) o;
        //o是字符串类型，不能强制转换成Integer类型，会报错ClassCastException
    }
}

A04：
分析下列代码的输出：

public class Homework04 {
    public static void main(String[] args) {
        try {
            showExce();//调用showExce方法，因为接收到了一个异常对象，所以进入catch块
            System.out.println("A");
        } catch (Exception e) {
            System.out.println("B");//1.输出B
        } finally {
            System.out.println("C");//2.输出C
        }
        System.out.println("D");//3.输出D
    }
    public static void showExce() throws Exception{
        throw new Exception();//直接抛出一个异常对象
    }
}
输出：
B
C
D