java第十二章：异常处理机制

最新推荐文章于 2024-09-13 21:40:38 发布

雾隐隐o

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量46

点赞数

分类专栏： JavaSE学习笔记分享文章标签： java python 开发语言

本文链接：https://blog.csdn.net/m0_74087660/article/details/134642326

版权

JavaSE学习笔记分享专栏收录该内容

15 篇文章 0 订阅

订阅专栏

java第十二章：异常处理机制

异常概念

程序执行过程中发生的异常事件分为：
	1)Error(错误):java虚拟机无法解决的严重问题，程序会崩溃
					如：StackOverflowError[栈溢出]和OOM(out of memory)
	2)Exception:运行时异常(程序运行时，发生的异常)
				编译时异常(编译器检查出的异常)

异常体系图

异常体系图小结

1.异常分为运行时异常和编译时异常
2.运行时异常是程序员应该避免其出现的异常
3.运行时异常很普遍，可以不做处理，若全处理可能会对程序的可读性和运行效率产生影响
4.编译时异常，是编译器要求必须处置的异常

常见的异常

五大运行异常

NullPointerException

ArithMeticException

ArithmeticException

ClassCastException

NumberFormatException

ArrayIndexOutOfBoundsException

编译异常

编译期间必须处理的异常，否则代码不能通过编译
常见的编译异常：
	SQLException//操作数据库时，查询表可能发生异常
	IOException//操作文件时，发生的异常
	FileNotFoundException//当操作一个不存在的文件时，发生异常
	ClassNotFoundException//加载类，而该类不存在时，发生异常
	EOFException//操作文件，到文件末尾，发生异常
	IllegalArguementException//参数异常

异常处理

t-c-f

try{
	代码//可能有异常
}catch(Exception e){
	//捕获到异常
	//1.当异常发生时
	//2.系统将异常封装成Exception 对象e，传递给catch
	//3.得到异常对象后，程序员自己处理
	//4.注意，如果没有发生异常，catch代码块不执行
}finally{
	//1.不管try代码块是否有异常发生，始终要执行finally代码块
	//2.所以，通常将释放资源的代码，放在finally
}

细节

1.如果没有出现异常，则执行try块中所有语句，不执行catch块中语句，如果有finally，最后还必须执行finally里面的语句
2.如果出现异常，则try块中异常发生后，try块剩下的语句不再执行，将执行catch块中的语句，如果有finally，最后还必须执行finally里面的语句
3.可以有多个catch语句，捕获不同的异常（进行不同的业务处理），要求父类异常在后，子类异常在前
4.可以try-finally配合使用，相当于没有捕获异常，就是不管是否发生异常，都必须执行某个业务逻辑（如释放资源）

练习

t-r-f练习1

t-r-f练习2

t-r-f练习3

课后练习题

t-r-f课后练习题

package com.lcz.exception.try_;

import java.util.Scanner;

/**
 * @author lcz
 * @version 1.0
 *
 * 需求：
 *      如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止(NumberFormatException)
 * 实现：
 *      1.while循环输入
 *      2.将输入字符串解析为int
 *      3.有异常则异常处理提示用户，
 *        无异常则break退出循环并输出整数
 */
public class Try {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String inputStr = "";
        int num = 0;
        while(true){
            System.out.println("请输入一个整数： ");
            inputStr = scanner.next();
            try {
                num = Integer.parseInt(inputStr);
                //若未发生异常
                break;
            } catch (NumberFormatException e) {
                System.out.println("您输入的不是整数！请重新输入");;
            }
        }
        System.out.println("您输入的整数是： " + num);
    }
}

throws

1.t-c-f 和 throws二选一

2.如果程序员，没有显式处理异常，默认是throws（指运行时异常的默认处理机制，而编译异常无默认处理机制，必须t-c-f 或 throws 才可编译通过）

JVM
//处理异常
//1.输出异常信息
//2.退出程序	
				main
				//try-catch-finally
				//throws
							f1方法
							//try-catch-finally
							//throws
										f2方法
										//try-catch-finally
										//throws

细节

1.在方法声明中，用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
2.对于编译异常，程序中必须处理，比如try-catch 或者 throws
3.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
4.子类重写父类的方法时，对抛出的异常的规定：子类重写的方法，所抛出的异常类型，要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型
5.在throws 过程中，如果有方法 try - catch ，就相当于处理异常，就可不必throws

自定义异常

1.自定义异常类名，继承Exception或RuntimeException
2.若继承Exception，属于编译异常
3.若继承RuntimeException，属于运行异常

注：一般情况下，我们自定义异常是继承 RuntimeException
	好处：可以使用默认的处理机制，比较方便

package com.lcz.exception.customexception;

/**
 * @author lcz
 * @version 1.0
 */
public class CustomException {
    public static void main (String[] args) throws MyException1{
        f1();
        throw new MyException("我的异常");
    }
    public static void f1() throws MyException1{
        throw new MyException1("我的异常1");
    }
}
class MyException extends RuntimeException{
    public MyException(String message) {
        super(message);
    }
}
class MyException1 extends Exception{
    public MyException1(String message) {
        super(message);
    }
}

throw和throws的对比

throw和throws区别

本章作业

1.编写应用程序，接受命令行的参数，计算两数相除

本章作业1

package com.lcz.exception.homework;

/**
 * @author lcz
 * @version 1.0
 * 需求：
 *      1.编写应用程序，接受命令行两个参数(整数)，编写cal方法计算两数相除
 *      2.对数据格式不正确(NumberFormatException)、缺少命令行参数(ArrayIndexOutOfBoundsException)
 *      、除0 进行异常处理(ArithmeticException)
 * 实现：
 *      1.判断命令行传入参数是否为2个
 *      2.将传入参数解析为整数
 *      3.编写cal方法并调用
 *      4.利用多个catch块进行不同的异常处理
 */
public class Homework01 {
    public static void main(String[] args) {
        try {
            //1.判断命令行传入参数是否为2个
            if(!(args.length == 2)){
                throw new ArrayIndexOutOfBoundsException("命令行参数异常");
            }
            //2.将传入参数解析为整数
            int n1 = Integer.parseInt(args[0]);
            int n2 = Integer.parseInt(args[1]);
            cal(n1,n2);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.getMessage());
        } catch (NumberFormatException e) {
            System.out.println(e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
    public static void cal(int n1,int n2){
        System.out.println("n1 / n2为：" + n1 / n2);//可能发生运行时异常--算术异常
    }
}