关于java的异常处理

关于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);
        }
    }
}

捕捉的好处，就是如果不捕获异常的话，程序碰到异常就直接终止了，但是捕获了以后，还是可以继续运行的，所以异常捕获十分的重要！