Java：异常

最新推荐文章于 2024-11-05 20:00:00 发布

原创最新推荐文章于 2024-11-05 20:00:00 发布 · 255 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#异常

Java_Path 同时被 3 个专栏收录

26 篇文章

订阅专栏

java

21 篇文章

订阅专栏

黑马笔记

14 篇文章

订阅专栏

异常概念

程序中异常的意思：在程序执行过程中，出现的非正常的清空，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身就是一个类，产生异常就是创建异常对象并抛出一个异常对象。Java处理异常的方式是中断处理。
注：异常指的不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行。

异常体系

异常机制帮助我们找到程序中的问题，异常的跟类是java.lang.Throwable，其下有两个子类：
- java.lang.Error
- java.lang.Exception
平常所说的异常时java.lang.Exception。

在这里插入图片描述

Throwable体系：

Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎

Throwable中的常用方法：

public void printStackTrace() : 打印异常的详细信息。
public String getMessage(): 获取发生异常的原因。
public String toString(): 获取异常的类型和异常描述信息（一般不用）。

出现异常，不要紧张，把异常的简单类名，拷贝到API中去查

异常分类

平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。
异常（Exception）的分类：根据在编译时期还是运行时期去检查异常？
- 编译时期异常：checked异常。在编译时期，就会检查，如果没有处理异常，则编译失败。（如日期格式化异常）
- 运行时期异常：runtime异常。在运行期间，检查异常。在编译时期，运行异常不会编译器检测（不报错）

在这里插入图片描述

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方
法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的
数据进来。这时需要使用抛出异常的方式来告诉调用者。
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

创建一个异常对象。封装一些提示信息(信息可以自己编写)。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw
就可以完成。throw 异常对象。
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数);

例如:

throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

throw的使用：

package heima.Exception;

/*
    throw关键字
    作用：
        可以使用throw关键字在指定的方法中抛出指定的异常
    使用格式：
        throw new xxxException(“异常产生的原因”)
    注意：
        1. throw关键字必须写在方法的内部
        2. throw关键字后边new的对象必须是Exception或者Exception的子类对象
        3. throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
            throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）
            throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws，要么try...catch
 */


public class _03Throw {
    public static void main(String[] args) {
        int[] arr = new int[3];
        int e = getElement(arr,3);
    }

    public static int getElement(int[] arr, int index){
        /*
            我们可以对传递过来的参数数组进行合法性校验
            如果数组arr的值是null
            那么我们就抛出空指针异常，告知方法的调用者“传递的数组的值是null”
         */
        if (arr == null){
            throw new NullPointerException("传递的数组值是null");
        }

        /*
            我们可以对传递过来的参数index进行合法性校验
            如果index的范围不在数组的索引范围内
            那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
        */
        if (index < 0 || index > arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }

        int x = arr[index];
        return x;
    }
}

声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲
解该方式），那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }

使用：

package heima.Exception;

/*
    throws关键字：异常处理的第一种方式，交给别人处理
    作用：
        当方法内部抛出异常对象的时候，我们必须处理这个异常对象
        可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理），最终交给JVM处理--->终端处理
    使用格式：在方法声明时使用
        修饰符 返回值类型 方法名（参数列表） throws AAAException，BBBException...{
            throw new AAAException("产生原因");
            throw new BBBException("产生原因");
        }
    注意：
        1. throws关键字必须写在方法声明处
        2. throws关键字后边声明的异常必须时Exception或者是Exception的子类
        3. 方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常
            如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
        4. 调用了一个声明抛出异常的方法，我们就必须处理声明的异常
            要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
            要么try...catch自己处理异常
 */

import java.io.FileNotFoundException;
import java.io.IOException;

public class _04Throws {
    // 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
    // FileNotFoundException extends IOException
    public static void main(String[] args) throws IOException {
        readFile("C:\\a.txt");
        System.out.println("后续代码");
    }

    /*
        定义一个方法,对传递的文件路径进行合法性判断
        如果路径不是"c:\\a.txt",那么我们就抛出文件找不到异常对象,告知方法的调用者
        注意:
            FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常
            可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理
     */

    public static void readFile(String filename) throws FileNotFoundException, IOException{
        if (!filename.equals("C:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是C:\\a.txt");
        }
        /*
            如果传递的路径不是txt结尾
            那么抛出IO异常对象，告知方法的调用者，文件的后缀名不对
         */
        if (!filename.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("路劲没有问题，读取文件");
    }
}

捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
在方法中使用try-catch的语句块来处理异常。
try-catch的方式就是捕获异常。
捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
捕获异常语法如下：

try{
        编写可能会出现异常的代码
}catch(异常类型 e){
        处理异常的代码
		//记录日志/打印异常信息/继续抛出异常
}

try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
注意：try和catch都不能单独使用,必须连用。

package heima.Exception;

/*
    try...catch...：异常处理的第二种方法，自己处理异常
    格式:
        try{
            可能产生异常的代码
        }catch(定义一个异常的变量，用来接收try中抛出的异常对象){
            异常的处理逻辑，异常对象之后，怎么处理异常对象
            一般在工作中，会把异常的信息记录到一个日志中
        }
        ...
        catch(异常类名 变量名){
        }
    注意：
        1. try 中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
        2. 如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完try中的代码，继续执行try。。catch之后的代码
 */

import java.io.IOException;

public class _05TryCatch {
    public static void main(String[] args) {

        try{
            // 可能产生异常的代码
            readFile("d:\\a.tt");
            System.out.println("资源释放");
        }catch(IOException e){
            // try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
            System.out.println("Catch - 传递的文件后缀不是.txt");
            /*
                Throwable类中定义了3个处理异常的方法
                String getMessage() 返回此 throwable 的简短描述
                String toString() 返回此 throwable 的详细消息字符串
                void printStackTrace() JVM打印异常对象，默认此方法，打印的异常信息是最全面的
            */
            e.printStackTrace();
        }
    }



    public static void readFile(String filename) throws IOException {
        if(!filename.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("路径没有问题,读取文件");
    }
}

finally代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行
不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的
finally的语法:
try…catch…finally:自身需要处理异常,最终还得关闭资源。（finally不能单独使用）

package heima.Exception;

/*
    finally代码块
    格式：
        try{
            可能产生异常的代码
        }catch(定义一个异常的变量，用来接收try中抛出的异常对象){

        }
        ...
        catch(异常类名 变量名){

        }finally{
            无论是否出现异常都会执行
        }

    注意：
        1. finally不能单独使用，必须和try一起使用
        2. finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放（IO）

 */

import java.io.IOException;

public class _06TryCatchFinally {
    public static void main(String[] args) {

        try{
            readFile("asdfasdf.txt");
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            //无论是否出现异常，都会执行
            System.out.println("资源释放");
        }

    }
    /*
   如果传递的路径,不是.txt结尾
   那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对

*/
    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("路径没有问题,读取文件");
    }
}

< 在这里插入图片描述

自定义异常

Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义
好的,此时我们根据自己业务的异常情况来定义异常类。

异常类如何定义:

自定义一个编译期异常: 自定义类并继承于 java.lang.Exception 。
自定义一个运行时期的异常类:自定义类并继承于 java.lang.RuntimeException 。

定义异常类

package heima.Exception;

/*
    自定义异常类：
        Java提供的异常类，不够我们使用，需要自己定义一些异常类
    格式：
        public class XXXException extends Exception | Run timeException{
            添加一个空参数的构造方法
            添加一个带异常信息的构造方法
        }
    注意：
        1. 自定义异常类一般都是以Exception结尾，说明该类是一个异常类
        2. 自定义异常类，必须继承Exception或者RuntimeException
            继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，要么throws，要么try...catch
            继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）
 */

public class RegisterException extends Exception{
//public class RegisterException extends RuntimeException{
    //添加一个空参数的构造方法

    public RegisterException() {
        super();
    }

    /*
        添加一个带异常信息的构造方法
        所有的异常类都会有一个带异常信息的构造方法，方法内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
     */

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

使用异常类

package heima.Exception;

/*
    要求：模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
    分析:
        1. 使用数组保存已经注册过的用户名（数据可）
        2. 使用Scanner获取用户输入的注册的用户名（前端，页面)
        3. 定义一个方法，对用户输入的注册用户名进行判断
            遍历存储已经注册过用户名的数组，获取每一个用户名
            与注册用户名比较
                true：用户名已存在，抛出RegisterException异常，告知用户“亲，该用户名已经被注册”）
                false：继续遍历比较
            循环结束，没有重复，则加入，提示用户注册成功
 */

import java.util.Scanner;

public class _08RegisterException {

    // 1.使用数组保存已经注册过的用户名(数据库)
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名");
        String username = in.next();
        checkUsername(username);
    }

    public static void checkUsername(String username){
        for (String name:usernames){
            if (name.equals(username)){
                try {
                    throw new RegisterException("亲，该用户名已经被注册");//抛出运行期异常,无需处理,交给JVM处理,中断处理
                } catch (RegisterException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("恭喜您，注册成功");
    }
//    public static void checkUsername(String username){
//        for (String name:usernames){
//            if (name.equals(username)){
//                throw new RegisterException("亲，该用户名已经被注册");//抛出运行期异常,无需处理,交给JVM处理,中断处理
//            }
//        }
//        System.out.println("恭喜您，注册成功");
//    }
}