入门JAVA 第八天 Java中的异常_java 最顶层异常类-CSDN博客

本文链接：https://blog.csdn.net/qq_57167753/article/details/129068548

本文详细介绍了Java的异常处理机制，包括异常、错误的定义，以及Java中的异常类层次结构。重点讲解了try、catch、finally关键字的使用，异常的分类，如NullPointerException、ClassNotFoundException等常见异常。同时，还探讨了如何创建和使用自定义异常，以及在方法上使用throws声明异常。最后，通过登录验证案例展示了异常处理在业务逻辑中的应用。

摘要由CSDN通过智能技术生成

一、Java异常处理机制

1.1 什么是异常

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

1.2什么是错误

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

1 语法错误 - 不能编译

2 运行时错误 - 常说的异常，语法正确，执行过程中出现错误。

在这类错误中，一部分原因是代码写错 ---------- 修改源文件。

在这类错误中，一部分原因是代码没写错，用户的问题 ---------异常处理

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

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

在Java中异常处理机制就是五个关键字：try，catch，finally，throw，throws

在Java中将每一种比较常见的异常情况，都封装了相应的异常类。例如：

NullPointerException，ClassCastException

在Java中异常父类：Exception（Exception extends Throwable）。

在Java中异常的顶层父类是：Throwable。

在Java中Throwable的另一个子类：Error extends Throwable。表示无法处理的重大异常错误。

1.4 try块

try{
	代码块;
}catch(Exceptin e){
    e.printStackTrace();
}

在Java中使用try关键字对Java代码进行监控。

如果监控中的代码出现了异常时：做两件事。

1 在try块中发生异常之后的代码，不在继续执行。

2 将异常封装成一个对应的异常类。抛出catch块进行处理

1.5 catch块一般格式

在java的异常处理中，catch负责接收try抛出的异常对象，并进行异常处理。

使用时，注意----catch块时不可以单独出现的。必须与try一起出现。

try{

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

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

1.6 Java中的异常类

(1) 异常父类Exception

a.String message 属性：异常信息。

b.构造方法：

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

c.实例方法：

public String getMessage(); //获取异常信息

public void printStackTrace(); //打印异常的堆栈信息

(2) RuntimeException类（面试）

RuntimeException 叫运行时异常。一般开发时不直接使用这个类。

RuntimeException 类将所有的异常类划分成两个阵营：检查异常和非检查异常

1 检查异常：时必须使用 try - catch 等进行异常处理的异常类

所有非 RuntimeException 类的子类的异常类

2 非检查异常：是可以不使用try - catch 等进行异常处理的异常类

所有 RuntimeException 类的子类

一般情况下。这类非检查异常都是因为代码写错了。

(4) 常见的异常类

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.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 User {
    private String userName;  //用户名
    private String userPass;  //密码
    private Integer userScore; //用户积分

    public User() {
    }

    public User(String userName, String userPass, Integer userScore) {
        this.userName = userName;
        this.userPass = userPass;
        this.userScore = userScore;
    }

    //get&set方法  获得&设置用户属性
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPass() {
        return userPass;
    }

    public void setUserPass(String userPass) {
        this.userPass = userPass;
    }

    public Integer getUserScore() {
        return userScore;
    }

    public void setUserScore(Integer userScore) {
        this.userScore = userScore;
    }

    //toString输出用户属性
    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", userPass='" + userPass + '\'' +
                ", userScore='" + userScore + '\'' +
                '}';
    }
}

2.4 编写数据访问对象

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

//在UserDao类中创建User类的数组对象来实现用户信息的存储
public class UsersDAO {
    private Users[] users = new Users[5];
}

(2)利用构造方法初始化

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);
    }
}

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

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 User findByName(String name){
        for (User user :
                this.user) {
            if (user == null){
                return null;
            }
            if (user.getUserName().equals(name)){
                return user;
            }
        }
        return null;
    }
}

2.5 编写业务处理对象

在业务处理对象中编写业务逻辑的实现。

同时，自定义的业务异常（用户名不存在，密码错误）需要在业务方法中抛出。

(1) 编写UserService类（依赖UserDao类）

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

(2) 编写登录验证方法

在登录验证这个业务过程中，有二个异常情况：

1 用户名不存在

2 密码错误

/**
     * 登录验证方法
     * @param userName 用户名
     * @param userPass 密码
     * @return 当验证成功时返回用户对象
     * @throws NameException 当用户名不存在时抛出的异常
     * @throws PassWordException 当密码错误时抛出的异常
     */
    publ
public class UserService {
    UserDao userDao = new UserDao();
    public User isLogin(String name,String pass) throws NameException,PasswordException{
        if (userDao.findByName(name) == null){
            throw new NameException("用户名不存在");
        }else{
            if (!userDao.findByName(name).getUserPass().equals(pass)){
                throw new PasswordException("密码错误");
            }
        }
        return userDao.findByName(name);
    }
}

2.6 编写测试类

public class Test {
    public static void main(String[] args) {
        UserService userService = new UserService();
        try {
            System.out.println(userService.isLogin("zhangsa", "123456").toString());
        }catch(NameException exception){
            System.out.println("这是你号吗，输的谁家的用户名");
            exception.printStackTrace();
        }catch( PasswordException exception){
            System.out.println("密码错了兄弟");
            exception.printStackTrace();
        }
    }
}