关于java的异常处理
我们在上一篇文章中，对java中的异常有了一个初步的了解，本篇文章我们来了解一下异常的处理机制，如何抛出异常，如何捕捉异常😀
关于java的异常
一、异常类型等级
二、关键字
- try
- catch
- finally
- throw
- throws
1、我们新建一个测试类，在里面声明两个变量a和b，a=1，b=0，输出a/b（我们知道这是错误的，所以要做异常处理）。
package exception;
public class Demo01 {
public static void main(String[] args) {
int a=1;
int b=0;
System.out.println(a/b);
}
}
我们输出一下，发现这是ArithmeticException类型的异常（算术异常）
Exception in thread "main" java.lang.ArithmeticException: / by zero
at exception.Demo01.main(Demo01.java:8)
2、我们用try catch做一下异常处理🐶，（fianlly可以不用，但是我们后期学习IO流的时候，要把资源关闭，可以理解为scanne.close）
package exception;
public class Demo01 {
public static void main(String[] args) {
int a=1;
int b=0;
try //监控区域
{
System.out.println(a/b);
}catch (ArithmeticException e)//捕获异常
{
System.out.println("程序出现异常，变量b不能为0");
}finally//处理善后工作
{
System.out.println("finally");
}
}
}
三、try catch 结构
try//异常监控
{
//需要监控的代码
}
catch()//异常类型捕获
{
//捕捉后执行的代码
}
1、我们做了异常处理以后，再执行一下代码，就会看到输出的是我们捕捉后进行处理的代码了。
程序出现异常，变量b不能为0
finally
2、我们再来定义两个方法，让他们互相调用。
package exception;
import struct.Test;
public class Demo01 {
public static void main(String[] args) {
int a=1;
int b=0;
try //监控区域
{
new Demo01().a();
}catch (ArithmeticException e)//捕获异常
{
System.out.println("不能互相调用！");
}finally//处理善后工作
{
System.out.println("finally");
}
}
public void a(){b();}
public void b(){a();}
}
3、我们执行以下代码，发现输出了finally，但是并没有捕捉到异常。
finally
Exception in thread "main" java.lang.StackOverflowError
at exception.Demo01.b(Demo01.java:22)
at exception.Demo01.a(Demo01.java:21)
at exception.Demo01.b(Demo01.java:22)
at exception.Demo01.a(Demo01.java:21)
- finally被正常输出出来了，因为它是善后工作所以执行。
- 没有捕捉到是因为，这个异常是个Error，是错误（StackOverflowError），所以要换一种方式捕捉，可以用Throwable，因为它的类型是最高的，catch(异常类型)。
package exception;
import struct.Test;
public class Demo01 {
public static void main(String[] args) {
int a=1;
int b=0;
try //监控区域
{
new Demo01().a();
}catch (Throwable e)//捕获异常
{
System.out.println("不能互相调用！");
}finally//处理善后工作
{
System.out.println("finally");
}
}
public void a(){b();}
public void b(){a();}
}
4、catch可以是多个，有点类似else if 满足其中一个就可以，所以要把最大的写在最后，如果写在前面的话，后面的异常处理就不执行了🤔
- 假设要捕获多个异常，从小到大捕获。
try//异常监控
{
//需要监控的代码
}
catch(Error e)//异常类型捕获
{
//捕捉后执行的代码
}
catch(Exception e)//Exception相对大一点
{
}
.....
catch(Throwable e)//最大的写在最后
{
}
四、快捷键
- CTRL+ALT+T
package exception;
public class Demo01 {
public static void main(String[] args) {
int a=1;
int b=0;
System.out.println(a/b);//选中，CTRL+ALT+T
}
}
- 有很多结构都是可以进行选择的，我们这里选择try/catch，然后就会自动生成一段代码出来了🐱
package exception;
public class Demo02 {
public static void main(String[] args) {
int a=1;
int b=0;
try {
System.out.println(a/b);
} catch (Exception e) {
throw new RuntimeException(e);//打印错误信息
}
}
}
package exception;
public class Demo02 {
public static void main(String[] args) {
int a=1;
int b=0;
try
{
System.out.println(a/b);
}
catch (Exception e)
{
System.exit(1);//结束程序
throw new RuntimeException(e);
}
}
}
五、主动抛出异常
-
throw
-
throws
-
二者的区别还是非常大的。
有时候我们知道代码中逻辑会有问题，所以我们选择去主动抛出异常，我们先来看一下throw。
package exception;
public class Demo02 {
public static void main(String[] args) {
int a=1;
int b=0;
try
{
if (b==0)
{
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a/b);
}
catch (Exception e)
{
//System.exit(1);
throw new RuntimeException(e);
}
}
}
- 上面代码执行的时候不会抛出什么，也看不见什么。
- 抛出异常大多数用在方法里面，所以我们在方法中试一下。
我们写一个除数的方法。
public void test(int a,int b)
{
if (b==0)
{
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a/b);
}
我们在上面调用以下这个方法，运行以下，就会抛出异常。
package exception;
public class Demo02 {
public static void main(String[] args) {
new Demo02().test(1,0);
}
}
Exception in thread "main" java.lang.RuntimeException: java.lang.ArithmeticException
at exception.Demo02.main(Demo02.java:18)
- 如果在方法中，处理不了这个异常，我们可以在方法上抛出异常，这个时候就用到了throws。
public void test(int a,int b) throws ArithmeticException
{
if (b==0)
{
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a/b);
}
这里我们调用的时候，用try catch 捕获一下。
package exception;
public class Demo02 {
public static void main(String[] args) {
try {
new Demo03().test(1,0);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
捕捉的好处，就是如果不捕获异常的话，程序碰到异常就直接终止了，但是捕获了以后，还是可以继续运行的，所以异常捕获十分的重要！
