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

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

5 断言 assert

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

注意,断言(assert)并不是用来代替if判断的,而是确认系统中的一些关键性条件必须成立的,所以assertif并不冲突,并且还可以通过给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执行代码的时候,会被直接忽略的

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值