Java异常捕获及处理 java异常捕获机制

文章目录

• 1.异常

• 什么是异常？
• 异常分类：
• 异常体系结构

• 2.捕获和抛出异常
• 3.自定义异常

1.异常

什么是异常？

异常分类：

异常体系结构

Error

Exception

2.捕获和抛出异常

异常处理机制：
步骤：1.抛出异常 2.捕获异常
异常处理五个关键字：

• try 监听异常，监控区域
• catch 捕获异常（捕获异常类型）
• finally 善后工作，可以不要，在IO或资源关闭使用，最后被执行
• throw 主动抛出异常，一般在方法中使用
• throws

选可能抛出的异常代码块，快捷键：Ctrl + Alt + T

例子1：捕获除数为0异常

package exception.demo01;

public class Test {
    public static void main(String[] args) {
        int a= 1;
        int b=0;
        try{//监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e) // 捕获想捕获的异常类型
        {
            System.out.println("程序出现异常，除数不能为0");
        }finally{// 处理善后工作，可以不要,IO,资源关闭可以使用
            System.out.println("finally");
        }
    }
}

例子2：捕获多个异常，异常顺序从小到大写，看异常体系结构，最大为Throwable，然后到Exception

package exception.demo01;

public class Test1 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try{
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("Error");
        }catch (Exception e){
            System.out.println("Exception");
        }catch(Throwable e){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }
    }

}

输出： 如果没有Exception，则输出Throwable

Exception
finally

例子3：捕获程序溢出异常，异常类型可为：Throwable（异常最大的父类）

package exception.demo01;
// 捕获栈溢出错误
public class Test2 {
    public static void main(String[] args) {

        try {
            new Test2().a();
        }catch (Throwable e){ //包含很多异常类型，不知啥可以使用Throwable类
            System.out.println("程序错误");
        }finally {
            System.out.println("finally");
        }
    }
    public void a(){
        b();
    }

    public void b(){
        a();
    }
}

例4：抛出异常

• 主动抛出异常:一般在方法中运用
• 假设在这个方法中，处理不了这个异常，方法上抛出异常
• 再在main中捕获该方法抛出的异常

package exception.demo01;

public class Test3
{
    //快捷键：Ctrl + Alt + T
    public static void main(String[] args) {
        try {
            new Test3().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();  //打印错误的栈信息
        }
    }

    //假设在这个方法中，处理不了这个异常，方法上抛出异常
    public void test(int a, int b) throws ArithmeticException{
    if(b==0){ // throw throws
            throw new ArithmeticException(); //主动抛出异常:一般在方法中运用
        }
        System.out.println(a/b);
    }

}

3.自定义异常

自定义异常步骤：

• 先继承 Exception
• 定义构造函数
• 重写toString，异常打印的信息

使用;

• 对于定义的函数，方法中使用throw抛出异常，若未解决方法上使用throws抛出异常
• 对于函数的使用：用try进行异常的监听，再使用catch进行捕获异常和处理
• 最后尽可能使用finally

package exception.demo02;
//自定义异常，继承Exception
public class MyException extends Exception{
    //传递数字
    private int detail;
    //构造函数Alt+c
    public MyException(int detail) {
        this.detail = detail;
    }
    //toString:异常打印的信息
    //快捷键：alt+c
    @Override
    public String toString() {
        return "MyException{" + "detail=" + detail + '}';
    }
}

package exception.demo02;

public class Test {
    //可能出现异常的方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为："+a);
        if(a>10){
            System.out.println("抛出异常或者在这个代码块解决下");
            throw new MyException(a); //方法中抛出异常，但是没有解决

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

    public static void main(String[] args) {
        try{
            test(18);
        }catch (MyException e){
            System.out.println("MyException:"+e);
        }
    }
}

输出：

传递的参数为：18
抛出异常或者在这个代码块解决下
MyException:MyException{detail=18}

坚持就是胜利！
木叶飞舞之处，火亦生生不息！愿不被岁月打到，我还能拥有一颗年轻的心！