异常处理

JAVA严格的异常处理机制和类型检查机制

异常处理
手贱异常
非手贱异常

异常链处理

异常是在程序出错的时候能知道程序哪里出错了

如果程序异常在底层报出以后 在过程中丢了 没有暴露出来 这个是不能容忍的

需要保证异常在一级一级的抛出的时候能保证异常没有丢失

异常：阻止当前方法或作用域顺利执行的问题
异常处理的意义和作用
java所有异常的根是 Throwable 类
Throwable 类有两个自类 Error类和Exception类
Error类 主要有 虚拟机错误（VirtualMachineError） 线程死锁（ThreadDeath）
Exception类：编码、环境、用户操作输入出现问题
分为 非检查异常 和 检查异常

处理异常
try-catch 以及 try-catch-finally

        Scanner input = new Scanner(System.in);
        try{int one = input.nextInt();
                int two = input.nextInt();
                System.out.println(one/two);}
        catch(InputMismatchException e){
            System.out.println("输入的数字必须为正整数");} 
        catch(ArithmeticException e){
            System.out.println("除数不能为0");}
        catch(Exception e){
            System.out.println("其他异常");}

异常抛出必须先小后大

测试一个 try catch 方法
e.printStackTrace();
这个方法是：在命令行打印异常信息在程序中出错的位置及原因。

package Java;
public class ex1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ex1 a = new ex1();
        int b = a.test();
        System.out.print("test方法运行完毕，返回值为"+b);
        
    }
    /**
     * divider(除数)
     * result(结果)
     * try-catch捕获while循环
     * 每次循环，divider减一 result = result+100/divider
     * 如果 捕获异常 打印输出“抛出异常了！！！” 返回 -1
     * 否则 返回 rusult
     * @return
     */
    public int test() {
        int divider = 10;
        int result = 100;
        try {
        while (divider > -1) {          
            divider --;
            result = result+100/divider;
            System.out.println(result);
        }
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("抛出异常了！！！");
            result = -1;
        }
        return result;
    }

}

try-catch-finally
在try捕获到异常执行了catch之后在返回main之前先执行了finally；
1、try
2、有异常执行catch
3、执行finally
4、返回main函数

package Java;
public class ex1 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ex1 ex = new ex1();
        int result = ex.test();
        System.out.print("test方法运行完毕，返回值为"+result);
    }
    /**
     * divider(除数)
     * result(结果)
     * try-catch捕获while循环
     * 每次循环，divider减一 result = result+100/divider
     * 如果 捕获异常 打印输出“抛出异常了！！！” 返回  result = 999
     * 否则 返回 rusult
     * finally:打印输出“这是finally！！！哈哈！！”，同时打印输出 result值
     * @return
     */
    public int test() {
        int divider = 10;
        int result = 100;
        try {
        while (divider > -1) {          
            divider --;
            result = result+100/divider;
            System.out.println(result);
        }
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("抛出异常了！！！");
            result = 999;
            return result;
        }
        finally {
            System.out.println("这是finally！！！哈哈！！" + result);
        }   
        return result;
    }
}

如果在try-catch-finally语句之内没有return语句则会调用之外的语句

package Java;
public class ex1 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ex1 ex = new ex1();
        int result = ex.test();
        System.out.print("test方法运行完毕，返回值为"+result);
    }
    /**
     * divider(除数)
     * result(结果)
     * try-catch捕获while循环
     * 每次循环，divider减一 result = result+100/divider
     * 如果 捕获异常 打印输出“抛出异常了！！！” 
     * 否则 返回 rusult
     * finally:打印输出“这是finally！！！哈哈！！”，同时打印输出 result值
     * 最后返回1111作为结果
     * @return
     */
    public int test() {
        int divider = 10;
        int result = 100;
        try {
        while (divider > -1) {          
            divider --;
            result = result+100/divider;
        }
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("抛出异常了！！！");
        }
        finally {
            System.out.println("这是finally！！！哈哈！！" + result);
        }
        System.out.println("这里是try-catch-finally之外的最后一句");
        result = 1111;
        return result;
    }
}

java中的异常抛出

throw

throws - 声明将要抛出何种类型的异常（声明）
public void 方法名（参数列表）
throws 异常列表{
//调用会派出异常的方法或者：
throw new Exception();
}

自定义异常
class 自定义异常类 extends 异常类型{
}

package Java;

public class ex extends Exception{
    public ex() {
        super();
    }
    public ex(String message) {
        super(message);
    }   
}   

异常链

package Java;
public class ex3 {
/**
 * test1():抛出"第一个异常"异常
 * test2():调用test1();捕获“第一个异常”异常，并且包装成运行时异常，继续抛出
 * main方法中，调用test2()尝试捕获test2()方法中的异常
 * @param args
 * @throws ex 
 */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ex3 ex3 = new ex3();
        try{
            ex3.test2();
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }

    public void test1() throws ex {
        throw new ex("第一个异常");
    }
    public void test2() {
        try {
            test1();
        } catch (ex e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        RuntimeException newExc = new RuntimeException("第二个异常");
        newExc.initCause(e);
        throw newExc;
        }
    }
}

image.png image.png