Java基础（异常）

最新推荐文章于 2022-03-28 22:45:11 发布

平平无奇的编码小天才

最新推荐文章于 2022-03-28 22:45:11 发布

阅读量238

点赞数

文章标签： java 编程语言 exception

本文链接：https://blog.csdn.net/CodeSheep1/article/details/108239080

版权

Java基础

1 异常

1.1 概述

程序在运行过程中，由于意外情况导致程序发生异常事件，默认情况下发生的异常会中断程序的运行。

在Java中，把常见的异常情况，都抽象成了对应的异常类型，那么每种异常类型都代表了一种特定的异常情况。

当程序中出现一种异常情况时，也会创建并抛出一个异常类型对象，这个对象就表示当前程序所出现的问题。

如图：
在这里插入图片描述

例如，程序中有一种异常情况是，当前使用下标从数组中取值的时候，这个下标值超过了数组下标的最大值，那么程序中就出现了异常情况，java中把这种异常情况抽象成了一个类：java.lang.ArrayIndexOutOfBoundsException，将来这个类的对象，就表示程序中出现了数组下标超过边界的异常情况。

public class Test {

    public static void main(String[] args) {
        int[] arr = {1,3,5,7};
        System.out.println(arr[2]);
        //这行代码执行时，出现异常情况，因为下标超过了数组的最大边界
        System.out.println(arr[4]);
    }

}
//运行结果：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
	at com.briup.demo.Test.main(Test.java:7)

可以看出，当前程序出现异常情况时，会创建并抛出和该异常情况对应的异常类的对象，这个异常对象中保存了一些信息，用来表示当前程序到底发生了什么异常情况。

通过异常信息，我们可以定位异常发生的位置，以及异常发生的原因

1.2 异常体系

异常体系中的根类是：java.lang.Throwable，该类下面有俩个子类型，java.lang.Error 和 java.lang.Exception

注意，Throwable表示可以被抛出的

在这里插入图片描述

Error，表示错误情况，一般是程序中出现了比较严重的问题，并且程序自身并无法进行处理。
Exception，表示异常情况，程序中出了这种异常，大多是可以通过特定的方式进行处理和纠正的，并且处理完了之后，程序还可以继续往下正常运行。

注意，我们一般说的异常，都是指的Exception

Exception中并没有定义方法，它的方法都是从Throwable中继承过来的，其中常用的方式有：

printStackTrace()，打印输出当前发送异常的详细信息（重要）
getMessage()，返回异常对象抛出是携带的信息，一般是异常的发生原因（重要）
printStackTrace(PrintWriter s)，方法重载，可以指定字符输出流，对异常信息进行输出
printStackTrace(PrintStream s)，方法重载，可以指定字节输出流，对异常信息进行输出

1.3 异常种类

我们平时使用的异常类型，都是Exception类的子类型，它们把异常划分成了俩种：

编译时异常
运行时异常

编译时异常，继承自Exception类，也称为checked exception，编译器在编译期间，会主动检查这种异常，发现后报错并提示我们要对这种异常进行处理。

运行时异常，继承自RuntimeException类，也称为unchecked exception，编译器在编译期间，不会检查这种异常，也不要求我们去处理，但是在运行期间，代码中可能会抛出这种类型的异常。

在这里插入图片描述

1.4 异常传播

如果一个方法中抛出了异常，并且一直没有进行处理，那么这个异常将会抛给当前方法的调用者，并一直向上抛出直到抛给JVM，最后JVM将这个异常信息打印输出，同时程序运行的停止。

public class Test {

    public static void main(String[] args) {
        System.out.println("hello");
        test1();
        System.out.println("world");
    }

    public static void test1(){
        test2();
    }
    public static void test2(){
        test3();
    }
    public static void test3(){
        int a = 1/0;
    }

}

//运行结果：
hello
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.briup.demo.Test.test3(Test.java:16)
	at com.briup.demo.Test.test2(Test.java:13)
	at com.briup.demo.Test.test1(Test.java:10)
	at com.briup.demo.Test.main(Test.java:5)

可以看出，test3方法中抛出了异常，因为是运行时异常，编译器不检查，这个异常在程序中没有处理，那么这个异常就抛给了test2，test2方法又将异常抛给了test1方法，test1中又将异常抛给main方法，main方法将异常抛给JVM，最后JVM将当前发生异常时，栈内存中方法的调用情况，打印输出，方便我们定位错误信息！之后JVM停止运行。

对应的栈区中，方法调用的情况：

可以看出，异常信息打印输出的内容，就是发生异常的时候，栈区中方法调用的情况！

test3方法中的第16行代码抛出异常，导致test2方法中的第13行也报错，因为test2方法中调用了test3方法

test2方法中的第13行报错，导致test1方法的第10行也报错，因为test1方法中调用了test2方法

test1方法中的第10行报错，导致main方法中的第5行也报错，因为main方法中调用了test1方法

这时候，test3方法中抛出的异常对象，就传播到了main方法中，main中也没处理，那么就把这个异常抛个JVM，那么JVM就打印输出异常信息，然后JVM停止运行！

所以程序最后停止在main方法中的第5行，test1方法的调用这句代码，下面的world也没有输出，因为JVM停止了，代码就不再往下执行了！

如果，在异常传播的过程中，任何一个地方对异常进行了处理，那么JVM不会停止，程序还会正常往下运行！

2 异常抛出

2.1 自动抛出异常

当前java代码中，出现了提前指定好的异常情况的时候，代码会自动创建异常对象，并且将该异常对象抛出。

例如，当代码中执行 int a = 1/0;的时候，代码会自动创建并抛出 ArithmeticException类型的异常对象，来表示当前的这种异常情况。（算术异常）

例如，当前代码中执行 String str = null; str.toString(); 的时候，代码会自动创建并抛出 NullPointerException 类型的异常对象，来表示当前这种异常情况。（空指针异常）

2.2 手动抛出异常

以上描述的异常情况，都是JVM中提前规定好的，我们不需要干预，JVM内部自己就会创建并抛出异常对象。

但是在其他的一些情况下，我们也可以手动的创建并抛出异常对象，其效果也是一样的。

例如，

public void test(String name){
    if(!"tom".equals(name)){
        throw new RuntimeException("用户名和预期不符！");
    }
}

注意，因为方法中抛出的是一个运行时异常，编译器不会做出检查，所以代码可以正常的编译运行，但是运行的时候，name的值不是tom的时候，代码会报错，这个错误信息是我们自己抛出的

例如，

public void test(String name){
    if(!"tom".equals(name)){
        throw new Exception("用户名和预期不符！");
    }
}

注意，以为方法中抛出的异常是编译异常，编译器会做检查，所以代码编译会报错，提示我们需要在test方法上声明出方法内抛出异常的类型，或者在方法内对这个异常进行处理！

例如，

public void test(String name)throws Exception{
    if(!"tom".equals(name)){
        throw new Exception("用户名和预期不符！");
    }
}

使用throws关键字，声明方法所抛出的异常类型即可

这个声明的目的，就是告诉test方法的调用者，你调用我的这个test方法的时候要小心啦，方法在运行的时候可能会抛出Exception类型的异常

这里描述为可能会抛出异常的原因是，只有name的值不是tom的时候才会抛出异常，其他情况没有异常！

我们在调用API中方法的时候，就需要注意这个方法是否声明了可能抛出的异常类型，例如forName方法

public final class Class{
    public static Class<?> forName(String className)throws ClassNotFoundException{
        //...
    }
}

可以看出，forName就声明了，方法在执行过程中可能会抛出 ClassNotFoundException类型的异常

同时，ClassNotFoundException属于编译异常，所以我们调用forName方法时候就要处理这个异常，或者将异常继续抛出！

思考，为什么方法内抛出异常对象使用关键字throw，方法上声明异常使用的是throws？

3 异常捕获

3.1 概述

当一个方法内，抛出了编译异常的时候，编译器在编译期间检查到，就会报错，提示我们有俩种修改方案：

把这个异常在方法上进行声明抛出
把这个异常再方法内进行捕获处理

例如，声明抛出

public void test(String className)throws ClassNotFoundException{
    
    Class.forName(className);
    
}

可以看出，这里我们并没有处理forName方法抛出的异常，而是将这个异常继续声明抛出，那么将来谁调用我们的test方法，谁就要处理这个异常情况

例如，捕获处理

public void test(String className){
    try {
        Class.forName(className);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

这里使用了try-catch语句块，对可能抛出异常的代码进行异常捕获处理

3.2 try-catch

try-catch语句块，就是用来对指定代码，进行异常捕获处理，并且处理完成后，JVM不会停止运行，代码还可以正常的往下运行！

捕获异常语法如下：

try{
	编写可能会出现异常的代码
}catch(异常类型 e){
	//处理异常的代码，可以是简单的输出异常信息，也可以使用日志进行了记录，也可以对数据进行修改纠正等操作
}

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，并对捕获到的异常进行处理。

例如，

public class Test {

    public static void main(String[] args) {
        System.out.println("hello");

        Test t = new Test();

        try {
            t.test("zs");
        } catch (Exception e) {
            //打印输出发生异常的时候，栈里面的方法调用情况，方便我们定位和修改代码
            e.printStackTrace();
        }

        System.out.println("world");
    }

    public void test(String name)throws Exception{
        if(!"tom".equals(name)){
            throw new Exception("用户名不正确");
        }
    }

}
//运行结果：
hello
world
java.lang.Exception: 用户名不正确
	at com.briup.demo.Test.test(Test.java:20)
	at com.briup.demo.Test.main(Test.java:9)

可以看出，try-catch语句处理过异常后，代码继续往下执行了，最后输出了world

3.3 捕获多种异常

如果try语句块中的多句代码，都会抛出异常，并且是不同类型的异常，那么catch语句块就有不同的写法，来处理这几个不同类型的异常。

例如，

public static void main(String[] args) {


    String className = "com.briup.demo.Student";
    String methodName = "sayHello";

    try {
        //forName声明抛出ClassNotFoundException
        Class c = Class.forName(className);
        //getMethod方法声明抛出NoSuchMethodException
        Method m = c.getMethod(methodName);
        //invoke方法声明抛出IllegalAccessException和InvocationTargetException
        m.invoke(null);
    } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        e.printStackTrace();
    }

}

这里，使用一个catch语句，里面使用 | 来表示捕获多种不同的异常类型

例如，

public static void main(String[] args) {


    String className = "com.briup.demo.Student";
    String methodName = "sayHello";

    try {
        //forName声明抛出ClassNotFoundException
        Class c = Class.forName(className);
        //getMethod方法声明抛出NoSuchMethodException
        Method m = c.getMethod(methodName);
        //invoke方法声明抛出IllegalAccessException和InvocationTargetException
        m.invoke(null);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }

}

这里，使用了四个catch语句，分别对四种不同的异常类型进行捕获处理

注意，这种异常处理方式，要求多个catch中的异常不能相同，并且如果catch中的多个异常之间有子父类异
常的关系的话，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

因为如果父类型异常再最上面的话，下面catch语句代码，永远不会被执行

例如，

public static void main(String[] args) {


    String className = "com.briup.demo.Student";
    String methodName = "sayHello";

    try {
        //forName声明抛出ClassNotFoundException
        Class c = Class.forName(className);
        //getMethod方法声明抛出NoSuchMethodException
        Method m = c.getMethod(methodName);
        //invoke方法声明抛出IllegalAccessException和InvocationTargetException
        m.invoke(null);
    } catch (Exception e) {
        e.printStackTrace();
    }

}

这里，使用了一个catch语句，但是捕获的异常类型是Exception，它最大的异常类型，由于多态的原因，Exception类型的引用e，可以捕获接收到任意类型的异常对象

3.4 finall语句

try-catch语句块，虽然可以捕获并处理异常情况，但是它也会改变代码的执行流程，例如：

public class Test {

    public static void main(String[] args) {
        System.out.println("hello");

        Test t = new Test();

        try {
            t.test("zs");
            System.out.println("briup");//注意观察，这句代码是否执行
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("world");
    }

    public void test(String name)throws Exception{
        if(!"tom".equals(name)){
            throw new Exception("用户名不正确");
        }
    }

}
//运行结果：
hello
world
java.lang.Exception: 用户名不正确
	at com.briup.demo.Test.test(Test.java:20)
	at com.briup.demo.Test.main(Test.java:9)

可以看出，以上代码中的第10行，并没有执行，因为第9行代码调用方法出现异常时，代码就从第9行跳到了11行的catch语句块，刚好吧11行的输出语句代码给跳过去了。

如图：

如果第11行是比较重要的代码，那么如何保证无论发生什么情况，它一定会被执行呢？

其实只要使用finally关键，就可以保证指定代码一定会执行，无论是否发生异常！

例如，try-catch-finally，固定搭配，类似于if-elseif-else，可拆开使用，也可以一起使用

public class Test {

    public static void main(String[] args) {
        System.out.println("hello");

        Test t = new Test();

        try {
            t.test("zs");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            System.out.println("briup");//这句代码一定会被执行
        }

        System.out.println("world");
    }

    public void test(String name)throws Exception{
        if(!"tom".equals(name)){
            throw new Exception("用户名不正确");
        }
    }

}

//执行结果：
hello
briup
world
java.lang.Exception: 用户名不正确
	at com.briup.demo.Test.test(Test.java:21)
	at com.briup.demo.Test.main(Test.java:6)

思考，以下代码中的finally中的代码是否会被执行

public static void main(String[] args) {
    System.out.println("hello");

    try {
        int a = 1;
        if(a>0){
            return;
        }
    } finally {
        System.out.println("briup");//是否会被执行？
    }

    System.out.println("world");
}

4 自定义异常

4.1 自定义异常的原因

JavaAPI中已经存在的异常类，都是当年sun公司，提前定义好的，它们分别表示着某一种已知的异常情况。

但是，在我们开发的系统中，大多数业务功能里面总会出现一些新的异常情况，而这些异常情况，当年sun公司定义异常类型的时候，肯定是想不到的.

例如，在学生信息管理系统中，学生的年龄设置为负数、学生的成绩大于了100分，用户登录时候的密码不正确、用户访问某些接口时候的权限不足等情况，在系统中都是异常情况，而这些异常类型在JavaAPI中都是没有的。

所以，在实际开发中，我们会自定义一些异常的类型，用来表示上面描述的那些异常情况，这样做的好处就是，我们通过观察系统的运行日志，就可以很快的知道当前系统是发生了什么事情，才导致出了这些异常情况。

4.2 如何自定义异常

如果要自定义一个编译时异常类型，就自定义一个类，并继承Exception
如果要自定义一个运行时异常类型，就自定义一个类，并继承RuntimeException

例如，自定义编译时异常类型，通过名字可知，这是在用户登录期间发生异常时，应该创建并抛出的异常类型

public class LoginExceptin extends Exception{
    public LoginExceptin(){
        
    }

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

例如，自定义运行时异常类型，通过名字可知，这是在修改用户信息期间发生异常时，应该创建并抛出的异常类型

public class ModifyUserInfoExceptin extends RuntimeException{
    public ModifyUserInfoExceptin(){

    }

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

当前我们在系统的日志信息中看到 LoginExceptin 和 ModifyUserInfoExceptin 这俩种异常类型的信息时，就知道是用户在登录和修改信息的时候，出现了问题。

5 断言 assert

断言（assert），是JDK1.4的时候，增加的一个关键字。用它可以在程序中，确认一些关键性条件必须是成立的，否则会抛出AssertionError类型的错误。（了解即可）

注意，断言（assert）并不是用来代替if判断的，而是确认系统中的一些关键性条件是必须成立的，所以assert和if并不冲突，并且还可以通过给JVM传参数，来控制断言（assert）是否生效。

断言（assert）的使用方式：

assert 布尔表达式;
//或者
assert 布尔表达式 : "错误信息";

当布尔表达式为true时，断言通过，否则抛出AssertionError类型错误

所以，assert后面的布尔表达式必须true才行。（也就是说条件必须成立）

例如，

public class Test {
	
	public static void main(String[] args) {
		
		Test t = new Test();
		t.test(0);
		
	}
	
	public void test(int a) {
		
		assert a!=0 : "参数a的值不能为0";
		
		int b = 10;
		int c = b/a;
		
		System.out.println(c);
		
	}
	
}

默认情况下，JVM是没有开启断言功能的，需要通过给JVM传参打开此项功能

需要使用 -enableassertions 或者 -ea JVM参数

例如，java -ea com.briup.demo.Test

使用eclipse运行时：
在这里插入图片描述

在这里插入图片描述

此时的运行结果为：因为断言要求参数a不能为0，但实际参数传的为0

Exception in thread "main" java.lang.AssertionError: 参数a的值不能为0
	at com.briup.demo.Test.test(Test.java:14)
	at com.briup.demo.Test.main(Test.java:8)

如果去掉-ea参数的话，那么断言（assert）语句，在JVM执行代码的时候，会被直接忽略的

平平无奇的编码小天才

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫