Java中的异常处理

发布时间:2024年01月15日

目录

前言:

异常简介:?

Error类:

Exception类:

Exception异常:

运行异常:?

编译异常:

throw和throws关键字:?

throw:

throws:

try-catch关键字:

finally:

为啥叫受查异常?

throw和throws的区别:

总结:


前言:

? ? ? ? 应该都听说过Java中的异常处理,其实不止Java中有异常处理,我们学过的其他语言中的报错是不是也是异常呢?对,是,但是Java中的异常为什么要学习?因为它可以当程序真的报错而崩溃时,我们进行异常处理可以使其跳过,程序还能正常的往下执行。

? ? ? ? 像C语言,如果程序报错就会崩溃,而Java可以得知这个异常,可以继续正常运行。

异常简介:?

? ? ? ? 异常就是异于常态,和正常情况不一样,有错误。在Java中,阻止当前方法或作用域的情况,称之为异常。

? ? ? ? Java中所有异常类都继承于Throwable类,对,你没听错,这些异常都是类。

????????Java中,所有异常都有一个公共祖先Throwable(可抛出)。Throwable指定代码中可用传播机制通过Java应用程序传输的任何问题的共性。

????????Throwable主要包括两个大类,一个是Error类,另一个是Exception类。

????????注意,异常和错误是两种东西。不是同一概念。

Error类:

????????其中Error类中包括虚拟机错误和线程死锁,一旦Error出现了,程序就彻底的挂了,被称为程序终结者。

Exception类:

????????也就是通常所说的“异常”。主要指编码、环境、用户操作输入出现问题,Exception主要包括两大类,非检查异常(RuntimeException)和检查异常(其他的一些异常)。?

? ? ? ? 因为Error类出现,程序就会挂掉,所以讲的意义不大。这一篇我们就来重点了解Exception类这个异常。?

Exception异常:

? ? ? ? Java中异常是分种类的,异常分为两大类:运行异常和编译异常(下图只是简单分类)。

? ? ? ? 比如算数异常:?

????????当发生异常时,不会再执行异常后面的代码。?

? ? ? ? 比如空指针异常和数组越界异常:

? ? ? ? ?此时我们来观察运行异常和编译异常的区别,比如我们利用递归来观察:

public static void func() {
    func();
}
public static void main(String[] args) {
    func();
}

? ? ? ? ?执行上面的代码会执行,之后报错。

?????????Error指的是Java虚拟机无法解决的严重问题,比如JVM的内部错误、资源耗尽等,比较典型的是:StackOverflowError 和 OutOfMemoryError(上面的死递归就是栈溢出)。

????????Exception:异常产生后程序员可以通过代码进行处理,是程序继续执行。

运行异常:?

? ? ? ? 异常分为运行时异常和编译时异常,我们刚才说的空指针异常,算术异常,数组下标越界访问异常都是运行异常。运行异常又称非受查异常。这个名字我们一会了解。

? ? ? ? 注意此时程序至少运行了。

编译异常:

????????那么接下来我们就来看看编译异常是什么。还记不记得我们之前讲的克隆方法,声明克隆接口表示能被克隆,要通过向下转型,还有要扔出异常才能被克隆。

class Person implements Cloneable{
    public String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("zhansan");
        Person person2 = (Person) person1.clone();
        System.out.println(person2);
    }
}

? ? ? ? 是否还记得我们当时一直出现红色标志,我们进行了向下转型,重写了该方法并且使用了Cloneable接口,但是还是不能运行,必须抛出异常才可以运行。其实这里就发生了编译异常。

?????????编译异常在编译期间一定要处理,否则代码不能编译通过。

????????那么我们有时候写出的会标红,这叫做语法错误。

throw和throws关键字:?

throw:

?????????如何让程序抛出异常?Java中抛出异常通常是使用throw和throws关键字来实现的。

? ? ? ? throw是将产生的异常抛出,是一个抛出异常的动作(一般是指定的异常)。

int a = 10;
if (a == 10) {
    throw new NullPointerException("hahaha");
}

? ? ? ? 通过throw来手动抛出异常。 我们之前的算数等等异常是JVM抛出的,因为我们没有处理。

????????throw关键字一般抛出我们自定义的异常。?

throws:

? ? ? ? throws一般使用在方法之后。

?????????告诉方法调用者,调用这个方法可能会抛出这个异常。也就是说,如果在方法中有这个编译时异常(受查异常),那么这个编译时异常一定要进行处理。目前我们的处理方式是在方法定义的时候,通过throws关键字声明异常。最后这个异常是交给JVM处理的。

????????throws必须跟在方法的参数列表之后,声明异常必须是Exception 或者Exception 的子类。

????????如果方法内存抛出了多个异常,throws之后必须跟多个异常类型,之间用逗号隔开;如果抛出的异常类型有父子关系,直接声明父类即可。

//public void OpenConfig(String filename) throws IOException, FileNotFoundException{
//FileNotFoundException 继承于 IOException
public void OpenConfig(String filename) throws IOException{
    
}//这两种方式是一样的

? ? ? ? 此时我们再来看一个代码:?

public static void func() throws CloneNotSupportedException{
    int a = 10;
    if (a == 10) {
        throw new CloneNotSupportedException("hahaha");
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
    func();//因为 func 方法的声明里面有编译异常处理,所以主方法也要写
}

? ? ? ? 但此时我们确实抛出异常了,但是程序还是崩溃了,那么异常实际上没有被程序员处理,实际上还是交给了JVM处理。

try-catch关键字:

? ? ? ? 程序员要解决这些异常,就需要使用这些语句:

public static void func() throws CloneNotSupportedException{
    int a = 10;
    if (a == 10) {
        throw new CloneNotSupportedException("hahaha");
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
    try {
        func();
    } catch (CloneNotSupportedException e) {
        throw new RuntimeException(e);
    }
}

? ? ? ? try语句中,可能会有异常发生,我们写这些语句是,是可以预测会发生那些异常的(身为程序员,我不信你看不出来),那么catch语句中,就是捕获这些可能发生的异常。?如果捕获到了就执行catch当中的内容。

? ? ? ? 如果我们预测失败,就是catch中没有捕获到发生的异常,还是会交给JVM处理,程序崩溃。?

? ? ? ? 我们可以通过catch捕获多个异常(就是多写几个catch语句):?

try {
    System.out.println(10/0);
} catch (ArithmeticException e) {
    System.out.println("我来处理 ArithmeticException 了");
} catch (NullPointerException e) {
    System.out.println("我来处理 NullPointerException 了");
}

? ? ? ? 这里处理的异常都是在try语句中的。我们也可以通过 | 连接多个异常,充当“或”。?

/*try {
    System.out.println(10/0);
} catch (ArithmeticException e) {
    System.out.println("我来处理 ArithmeticException 了");
} catch (NullPointerException e) {
    System.out.println("我来处理 NullPointerException 了");
}*/

//以下方式等同上面,但是少用
try {
    System.out.println(10/0);
} catch (ArithmeticException | NullPointerException e) {
    System.out.println("我来处理 ArithmeticException 了");
}

????????也就是说,在try里面发生的异常,就不会执行里面的代码了。?

????????虽然可以捕获多种类型异常,但是同一时刻只能抛出一个异常。

????????我们不能先捕获所有父类异常之后捕获子类异常,否则出错。

????????但是可以先捕获子类异常,之后捕获父类异常,此时就充当了垫后的角色。

? ? ? ? 还有就是,那几个运行异常的类型最好记住,如果我们使用了try-catch语句,就一定要知道可能会出现哪些异常。当然,我们知道所有异常都继承Exception类,刚才说可以使用父类来指代。但是最好不要使用父类,否则这样就失去了意义。

finally:

? ? ? ? 你猜它为啥叫finally?我们先看代码:

public static int func() {
    try {
        int[] array = null;
        System.out.println(array.length);
    } catch (NullPointerException e) {
        System.out.println("捕获到了一个空指针异常");
    } finally {
        System.out.println("这里执行了finally");
    }
    return 10;
}
public static void main(String[] args) {
    System.out.println(func());
}

? ? ? ? 可以看到,?finally最后无论如何都会被执行。

? ? ? ? 这里面会有很多抗,也就是说我们必须知道执行顺序,比如以下代码结果:

? ? ? ? 因为try里面直接返回了,但是finally还是被执行了。那么既然如此,我们就不能乱返回了:?????????因为可能不止一条语句执行,所以返回值不能有多个。

? ? ? ? 执行顺序:try中的语句正常,就先执行finally,之后执行try;try中的语句有异常,就先执行catch里面捕获到的异常语句,之后执行finally。

? ? ? ? 所以try里面没有异常,要先执行finally:

public static int func1() {
    try {
        return 10;
    } finally {
        return 100;
    }
}
public static void main(String[] args) {
    System.out.println(func1());
}

????????这个结果为100,此时直接执行finally,并不在执行try里面的代码。?

? ? ? ? 我们先来执行一个异常代码:

????????此时func2里面没有处理这个异常,main方法中处理了这个异常,那么这个func2方法就最好声明一下,让使用者知道会有异常并处理。?

public static void func2() throws ArrayIndexOutOfBoundsException{
    //声明会有这个异常让使用者处理
    int[] arr = {1,2,3};
    System.out.println(arr[100]);
}
public static void main(String[] args) {
    //此时因为是 main 方法调用,所以要在 main 方法中处理
    //使用 try-catch
    try {
        func2();
    } catch (ArrayIndexOutOfBoundsException e) {

    } finally {
        
    }

}

?????????所以调用的方法中也没有处理,最终就会交给JVM来处理。

为啥叫受查异常?

? ? ? ? 为了更好的理解,我们来举一个例子,我们来自定义异常,因为异常本来就是类,所以我们利用继承来自己定义异常。

????????我们可以看到,像ArrayIndexOutOfBoundsException这个异常是继承于IndexOutOfBoundsException的,所以我们自己写异常时,就需要用到继承于Exception中的类来写。

? ? ? ? 此时我们定义一个LogIn类,并在里面对比用户名和密码,如果对照错误,则抛出自己定义的异常。?

public class LogIn {
    private String userName = "admin";
    private String password = "123455";
    private static void loginInfo (String userName, String password) {
        if (!userName.equals(userName)) {
            //此时用户名输入错误,就需要报异常
            //此时抛出自定义异常
            throw new UserNameException("用户名有问题");
        }
        if (!password.equals((password))) {
            //此时密码错误
            throw new PasswordException("密码有问题");
        }
        System.out.println("登陆成功");
    }

    public static void main(String[] args) {
        loginInfo("admin","123456");
    }
}

//extends Exception          编译时异常
//extends RuntinmeException  运行时异常

class UserNameException extends Exception {
    //自定义异常一定要继承于异常
    //此时为编译时异常
    public UserNameException (String message) {
        super(message);
    }
}

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

?????????此时报红是因为这是一个受查异常,所以需要通过try-catch包起来。但是我们之前讲过,可以通过调用它的函数try-catch,有异常的函数只需要通过声明可能有异常即可。

public static void main(String[] args) {
    //此时通过throws已经声明了异常
    //调用方法里面需要通过 try-catch 来解决
    try {
        loginInfo("admin","123456");
    } catch (UserNameException e) {
        
    } catch (PasswordException e) {
        
    } finally {
        
    }
    
}
private static void loginInfo (String userName, String password) throws UserNameException,PasswordException{
    if (!userName.equals(userName)) {
        //此时用户名输入错误,就需要报异常
        //此时抛出自定义异常
        throw new UserNameException("用户名有问题");
    }
    if (!password.equals((password))) {
        //此时密码错误
        throw new PasswordException("密码有问题");
    }
    System.out.println("登陆成功");
}

? ? ? ? 因为这是受查异常,因为我们继承了编译异常的类,所以必须解决。所以运行异常(非受查异常)就不用解决了。

? ? ? ? 注:因为空指针异常,算数异常不是编译异常,所以你在主方法后面不加上throws也可以通过,由JVM来帮你处理。

? ? ? ? 我们见过一个最典型的受查异常(编译异常)就是克隆方法了,我们当时主方法调用克隆方法,这个主方法就必须使用throws关键字,否则无法完成编译。

throw和throws的区别:

????????1、throws出现在方法函数头;而throw出现在函数体。
? ? ? ? 2、throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某种异常对象。
????????3、两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用处理。

总结:

? ? ? ? 多去刷题,多去使用,就会领悟。

文章来源:https://blog.csdn.net/weixin_64132124/article/details/135609699
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。