异常处理机制

Lzzzzzzk

已于 2023-03-08 15:00:59 修改

阅读量249

点赞数 1

分类专栏： Javase + Java面向对象 + 线程文章标签： java jvm servlet

于 2023-02-16 21:46:29 首次发布

本文链接：https://blog.csdn.net/Lzzzzzzk/article/details/129071405

版权

Javase + Java面向对象 + 线程专栏收录该内容

17 篇文章 0 订阅

订阅专栏

2023.02.16 星期四

1 Java异常处理机制

1.1 什么是异常？

异常是错误。异常是一种运行时的错误。

1.2 什么是错误？

在Java中错误分为如下三种类型：

1 语法错误 - 不能编译

2 运行时错误 - 常说的异常，语法正确，执行过程中出现错误。
在这类错误中，一部分原因是代码写错 ------ 修改源文件。
在这类错误中，一部分原因是代码没写错，用户的问题 ------- 异常处理

3 逻辑错误 - 语法正确，运行时也没有错误，但就是结果不对。

1.3 Java异常处理机制的关键字和异常类

在Java中异常处理机制就5个关键字：try,catch,finally,throw,throws
在Java中将每一种比较常见的异常情况，都封装了相应的异常类。例如：NulPorinterException。ClassCaseException

在Java中异常父类：Exception extends Throwable。
在Java中异常的顶层父类：Throwable。
在Java中Throwable的另一个子类：Error extends Throwable。表示无法处理的重大异常错误。
在这里插入图片描述

1.4 try块

try{
	代码块;
}

在Java中使用try关键字对Java代码进行监控。
如果监控中的代码出现了异常时：做二件事
1 在try块中发生异常之后的代码，不再继续执行。
2 将异常封装成一个对应的异常类。抛出给catch块进行处理。

1.5 catch块一般格式

在java的异常处理中，catch负责接收try抛出的异常对象，并进行异常处理。
使用时，注意：：：：catch块是不可以单独出现的。必须与try一起出现。

try{
	被监控的代码块;
}catch(异常类   异常类对象){
	异常处理的代码块;
}

catch块的异常类，一定要能出try块抛出的异常类匹配。这样catch块才能接收异常并处理。

1.6 Java中的异常类

一般我们叫的异常类：java.lang.Exception类。Exception表示了任意类型的异常。

1.6.1 异常父类Exception

1 String message 属性：异常信息。
2 构造方法：

public Exception(String message) {
    super(message);
}

3 实例方法：

public String getMessage();	获取异常信息
public void printStackTrace();	打印异常的堆栈信息。

在这里插入图片描述

1.6.2 RuntimeException类（面试）

RuntimeException叫运行时异常。一般开发时不直接使用这个类。
RuntimeException类将所有的异常类划分成了二个阵营：检查异常和非检查异常
1 检查异常：是必须使用 try-catch等进行异常处理的异常类。
所有非RuntimeException类的子类的异常类
一般情况下，都是因为外部原因产生的异常。程序本身没有错误。
2 非检查异常：是可以不用使用try-catch等进行异常处理的异常类。
所有RuntimeException类的子类
一般情况下。这类非检查异常都是因为代码写错了。
在这里插入图片描述

1.6.3 常见的异常类

1 NullPointerException 空指针异常。一个为null的对象打点调用方法。
2 ClassNotFoundException 类没有找到异常。创建类对象时，类名不存在。
3 ArithmeticException 算术异常。/0
4 ArrayIndexOutOfBoundsException 数组下标越界
5 NumberFormatException 数值格式错误异常。文字转换为数值类型时，文字不是一个数值格式。
6 ClassCastException 类型转换异常。父类向子类转换时，发现父类不是对应子类的类型。

1.7 多重catch块

try{
}catch(异常类 o){
}catch(异常类 o){
}

当try块监控的代码有可能出现多种异常时，在catch块中可以针对每一种不同的异常进行针对性的异常处理。

public static void main(String[] args) {
    String s = "com.xja.test.Test0";
    try {
        System.out.println(5/0);
        System.out.println("1");
        Class.forName(s);
        System.out.println("2");
    } catch (ClassNotFoundException e) {
        System.out.println("类没有找到！");
        e.printStackTrace();
    } catch (ArithmeticException e) {
        System.out.println("除数不能为零！");
        e.printStackTrace();
    } catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("end");
}

1.8 多重catch块变化版

public class Test03 {
    public static void main(String[] args) {
        String s = "com.xja.test.Test0";
        try {
            System.out.println(5/0);
            System.out.println("1");
            Class.forName(s);
            System.out.println("2");
        } catch (ClassNotFoundException|ArithmeticException e) {
            e.printStackTrace();
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

1.9 finally块

try-catch-finally
try-finally

try{
}catch(异常类 o){
}finally{
}

finally块表示一定会执行的部分。

一般资源释放，连接关闭，数据清空等放到finally块。

版本一：
在当前结构中，如果在“操作资源”时发生了异常。“释放资源”就不会执行了。

try{
	获取资源；
	操作资源；
	释放资源；
}catch(Exception e ){

}

版本二：一定要释放资源

try{
	获取资源；
	操作资源；
}catch(Exception e ){

}finally{
	释放资源；
}

1.10 throw关键字

注意：throw关键字的使用格式非常简单。
但是一定要注意throw关键字的使用方式。
throw关键字一定要配合自定义异常一起使用。
throw关键字是手动抛出异常的关键字。
throw new 异常类();

public class Test07 {
    public static void main(String[] args) {
        try{
            throw new Exception("异常信息！！！！");//手动抛出异常
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

1.11 自定义异常类

创建一个自定义的异常类。非常简单，就是一个单纯的继承。

	public class 自定义异常类 extends Exception{ }

我们自己编写的异常类。系统是不认识的。系统是不能像NullPointerException一样自动捕获，自动抛出的。
所以我们自己编写的自定义的异常类，必须配合throw 一起使用。使用手动抛出的方式。

public class NameException extends Exception{
    public NameException() {
    }
    public NameException(String message) {
        super(message);
    }
}

1.12 throw 与自定义异常的使用规则

自定义异常类一般都是处理业务逻辑的规则。
编写NameException 表示用户名的异常。
例如：登录时没有找到相同的用户名，是异常
注册时找到了相同的用户名，是异常

throw一般都是在业务逻辑错误的情况。手动去抛出异常。

public static void main(String[] args) {

    String userName = "admin";
    String password = "123456";

    //进行登录验证。先验证用户名再验证密码。验证用的用户名admins,密码123456
    try {
        if ("admins".equals(userName)) {
            if ("123456".equals(password)) {
                System.out.println("登录成功！");
            } else {

            }
        } else {
            throw new NameException("用户名不存在！");
        }
    } catch (NameException e) {
        e.printStackTrace();
    }
    System.out.println("end");
}

1.13 补充密码错误的自定义异常类

public class PassWordException extends Exception{
    public PassWordException(String message) {
        super(message);
    }
}
public class Test08 {
    public static void main(String[] args) {
        String userName = "admin";
        String password = "123456";
        //进行登录验证。先验证用户名再验证密码。验证用的用户名admins,密码123456
        try {
            if ("admins".equals(userName)) {
                if ("123456".equals(password)) {
                    System.out.println("登录成功！");
                } else {
                    throw new PassWordException("密码错误！");
                }
            } else {
                throw new NameException("用户名不存在！");
            }
        } catch (NameException | PassWordException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

1.14 throws方法声明异常

throws关键字是用来方法声明上的关键字。
throws关键字是用来表示当前这个方法，被调用时，有可能抛出的异常。让调用者处理。

	public class 类{
		public void fun()  throws  方法可能抛出的异常类;
}

我们编写的自定义的异常类。是为了处理业务逻辑中的异常。业务逻辑是在service层编写的代码。

2 优化登录验证案例

2.1 main方法的代码

public static void main(String[] args) {
    String userName = "admin";
    String password = "123456";
    //进行登录验证。先验证用户名再验证密码。验证用的用户名admins,密码123456
    try {
        if ("admins".equals(userName)) {
            if ("123456".equals(password)) {
                System.out.println("登录成功！");
            } else {
                throw new PassWordException("密码错误！");
            }
        } else {
            throw new NameException("用户名不存在！");
        }
    } catch (NameException | PassWordException e) {
        e.printStackTrace();
    } catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("end");
}

2.2 工程结构

在这里插入图片描述
domain ：实体域对象。表示一个真实实体的类的包。
dao : database access object 数据访问对象。负责操作数据。
service : 业务层，负责业务逻辑处理。这层的方法才会抛出业务异常。
service层依赖于 dao层

2.3 编写用户实体类

public class Users {
    private String userName;
    private String userPass;
    private Integer userScore;
}

2.4 编写数据访问对象

编写保存注册用户的数组对象

public class UsersDAO {
    private Users[] users = new Users[5];

利用构造方法初始化

public class UsersDAO {
    private Users[] users = new Users[5];

    public UsersDAO() {
        users[0] = new Users("admin","123456",100);
        users[1] = new Users("user","123456",100);
    }
}

编写按用户名查询用户对象的方法

public class UsersDAO {
    private Users[] users = new Users[5];//保存注册用户信息的数组
    /**
     * 默认构造方法
     */
    public UsersDAO() {
        users[0] = new Users("admin","123456",1000);
        users[1] = new Users("user","123456",100);
    }

    /**
     * 按用户名查询用户对象的方法
     * @param userName 用户名
     * @return 用户对象，如果没查到返回null。
     */
    public Users selectByName(String userName){
        for (Users u : users){
            if(u == null){
                return null;
            }
            if(u.getUserName().equals(userName)){
                return u;
            }
        }
        return null;
    }
}

2.5 编写业务处理对象

在业务处理对象中编写业务逻辑的实现。
同时，自定义的业务异常（用户名不存在，密码错误）需要在业务方法中抛出。
编写UsersService类

public class UsersService {
}

编写依赖的UsersDAO对象

public class UsersService {
    private UsersDAO usersDAO = new UsersDAO();
}

编写登录验证的方法
在登录验证这个业务过程中，有二个异常情况：
1 用户名不存在
2 密码错误

public class UsersService {
    private UsersDAO usersDAO = new UsersDAO();
    /**
     * 登录验证方法
     * @param userName 用户名
     * @param userPass 密码
     * @return 当验证成功时返回用户对象
     * @throws NameException 当用户名不存在时抛出的异常
     * @throws PassWordException 当密码错误时抛出的异常
     */
    public Users isLogin(String userName, String userPass)
            throws NameException, PassWordException {
        Users user = this.usersDAO.selectByName(userName);
        if(user == null){
            throw new NameException("用户名不存在！");
        }else{
            if(userPass.equals(user.getUserPass())){
                return user;
            }else{
                throw new PassWordException("密码错误！");
            }
        }
    }
}