java异常注意点

本片博客主要讲以下异常的注意点。

1. 如果异常不被try catch捕捉，异常会给jvm处理，程序就立即停止了。

public static void main(String[] args) {
    int[] array = {1,2,3};
    System.out.println(array[5]);
    System.out.println("haha!");
}

这里的 'haha' 就不会执行。

---

 但是，在try中写上面的代码，'haha'也不会执行。

    public static void main(String[] args) {
        int[] array = {1,2,3};
        try {
            System.out.println(array[5]);
            System.out.println("haha!");//上面错了,这里不执行
        }catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
            System.out.println("我捕捉到了一个数组越界异常，这里开始处理异常了");
        }
        System.out.println("哈喽！！！");//能打印
    }

try中是正常代码，如果有异常，会去看catch捕捉到没

捕捉到了就执行catch内的语句，没有捕捉到就给jvm处理 

像下面就没捕捉到，直接报错：

   

2. catch捕获异常时，要先写异常父类，再写其子类

倒过来写就对了

    

3.即使有异常没捕捉，finally都会执行

finally一般用作资源的关闭

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int n = scanner.nextInt();
            System.out.println(10 / n);
        } catch (InputMismatchException e) {
            e.printStackTrace();
            System.out.println("输入有误！");
        } finally {
            //一般用作 资源的关闭
            scanner.close();
            System.out.println("finally执行了！");
        }
    }

捕捉的情况：

正常情况 

---

 既然finally怎样都会执行，那么就要避免在finally中return

    public static int func3() {
        int a = 10;
        try {
            //System.out.println(10/0);
            return a;
        }catch (ArithmeticException e) {
            e.printStackTrace();
        }finally {
            return 20;
        }
    }
    public static void main10(String[] args) {
        System.out.println(func3());
    }

 

结果是20

     

4. 遇到异常会先在函数内找异常处理方式

函数内找不到就沿着栈向上传递，一直到main函数

    public static void func2(int n) throws ArithmeticException{
        try {
            System.out.println(10/n);
        }catch (ArithmeticException e) {
            System.out.println("func2()");
            e.printStackTrace();
        }
        // System.out.println(10/n);
    }
    public static void main9(String[] args) {
        try {
            func2(0);
        }catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("main()");
        }
        System.out.println("ffsad");
    }

所以，如果main函数和函数内都有异常处理方式，优先用函数的。

但是，如果连main函数都没有异常处理方式，那么就会交给jvm处理。

这里列举异常的处理步骤：

1. 程序先执行 try 中的代码

2. 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.

3. 如果找到匹配的异常类型, 就会执行 catch 中的代码

4. 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.

5. 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).

6. 如果上层调用者也没有处理的了异常, 就继续向上传递.

7. 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

    

5. 除了try catch，还有一个方法来捕获异常，那就是throws

    public static void func4(int x) throws ArithmeticException {
        if(x == 0) {
            //System.out.println(10/x);
            throw new ArithmeticException("/ by 0");
        }
    }

    

6. 受查异常与非受查异常

受查异常，继承于Exception

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

非受查异常，继承于RuntimeException

class MyException2 extends RuntimeException{
    public MyException2(String message) {
        super(message);
    }
}

受查异常与非受查异常的区别：

受查异常需要try catch包裹或者手动throws抛出(必须被显式处理)，否则编译不通过

非受查异常就不用显式处理

public class TestDemo3 {

    //受查异常需要try catch包裹或者手动throws抛出，否则编译不通过
    public static void func1(int x) {
        try {
            if(x == 0) {
                throw new MyException("heihei");
            }
        }catch (MyException e) {
            e.printStackTrace();
        }
    }

    //throws来显式处理
    public static void func2(int x) throws MyException{
        if(x == 0) {
            throw new MyException("hahah");
        }
    }

    //非受查异常不用
    public static void func3(int x){
        if(x == 0) {
            throw new MyException2("heihei");
        }
    }
}

 还要补充一点：

一个受查异常的方法，在调用这个方法时必须要用try catch或者throws来包裹

但是非受查异常就不用

   

谢谢你看到这🦀🦀，希望大佬点个👍