java中的异常(带你全面了解异常)

1.Java的异常体系

Java 内置了丰富的异常体系, 用来表示不同情况下的异常.

下图表示 Java 内置的异常类之间的继承关系:

java中的异常(带你全面了解异常)_第1张图片

来看下图:

java中的异常(带你全面了解异常)_第2张图片

编译时异常意味着如果不处理这个异常的话,编译时就不能通过,直接飘红

运行时异常是运行的时候才发生的异常

 2.异常的核心思想

异常的核心思想就是EAFP.

EAFP:It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理.

所以说异常的核心思想其实就是程序先执行,出现异常了再去解决

我们来看一段EAFP风格的代码,稍后会对这段代码进行解释:

try {

登陆游戏();

开始匹配();

游戏确认();

选择英雄();

载入游戏画面();

...

} catch (登陆游戏异常) {

处理登陆游戏异常;

} catch (开始匹配异常) {

处理开始匹配异常;

} catch (游戏确认异常) {

处理游戏确认异常;

} catch (选择英雄异常) {

处理选择英雄异常;

} catch (载入游戏画面异常) {

处理载入游戏画面异常;

}

 3.异常的基本用法

3.1捕获异常

基本语法

try{

有可能出现异常的语句 ;

}[catch (异常类型 异常对象) {

} ... ]

[finally {

异常的出口

}]

1:try 代码块中放的是可能出现异常的代码.

2:catch 代码块中放的是出现异常后的处理行为.

3:catch括号总放入的是可能会出现的异常类型和异常对象

4:finally 代码块中的代码用于处理善后工作, 会在最后执行.

5:其中 catch finally 都可以根据情况选择加或者不加.

3.2代码示例

代码1 使用try catch来处理异常

1:假设此时我们不用try catch来处理异常

public class yichang {
    public static void main(String[] args) {
        int a = 0;
        System.out.println(10 / a);
        System.out.println("hh");
    }
}

运行后我们会发现此时最后一句输出语句根本不会被执行,原因是System.out.println(10/a)这条语句发生了算数异常,所以根本不会执行 System.out.println("hh"); 这条语句.

总结:假如不使用try catch处理异常的话,便会交给jvm处理异常,最终程序会异常终止,且不会继续执行发生异常之后的代码.

当使用try catch来处理异常后

public class yichang {
    public static void main(String[] args) {
        int a = 0;
        try {
            //try中存放的是可能会发生异常的代码
            System.out.println(10 / a);
            System.out.println("hhhh");
        } catch (ArithmeticException e) {
            //catch代码块放入的是处理异常的代码
         
        }
       
        System.out.println("hh");
    }
}

     
    //输出结果为
    hh

我们会发现当我们使用了try catch来处理了这个算术异常后,此时输出结果为hh.

同样System.out.println("hhhh")这句话不会执行,原因是在System.out.println(10/a)处发生了异常.

在来看一段代码:

public class yichang {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println("before");
            System.out.println(arr[100]);
            System.out.println("after");
        } catch (ArrayIndexOutOfBoundsException e) {
            // 打印出现异常的调用栈
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
}


     //输出结果为
     before
     java.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:10)
     after try catch

 e.printStackTrace为打印出现异常的调用栈,所以就会出现输出结果中的第二行的话

代码2 catch 只能处理对应种类的异常

继续来看下面的代码,我们可以看到此时try中的代码会发生空指针异常,但是catch中捕获的却是数组越界异常,那么最终的System.out.println("after try catch");这条语句是不会被执行到的,原因是catch中所捕获的异常类型与实际发生的异常不匹配,所以处理异常失败。

public class yichang {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println("before");
            arr = null;
            System.out.println(arr[100]);
            System.out.println("after");
        } catch (ArrayIndexOutOfBoundsException e) {
            /*e.printStackTrace();*/
        }
        System.out.println("after try catch");
    }
}

 最终输出结果为:

Exception in thread "main" java.lang.NullPointerException at yichang.main(yichang.java:11)

before

代码3 catch可以捕获多个异常

方法1:

public class yichang {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //catch代码块可以捕获多个异常
        try {
            System.out.println("before");
            System.out.println(arr[100]);
            //因为此时上面的代码发生了异常,所以此时下面的代码是不会被执行的。
            System.out.println("after");
        } catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("此段代码不会执行");

        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
            System.out.println("捕获了数组越界异常");
        }
        System.out.println("after try catch");
    }
}

  

    //输出结果为
    before
    捕获了数组越界异常
    after try catch
    java.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:11)

假如此时try中的代码发生的是数组下标越界异常,但是第一个catch中捕获的却是算术异常,那么这个catch中的代码是不会被执行的,第二个catch捕获的是数组下标越界异常,那么就会正常执行里面的代码,最后再执行System.out.println("after try catch");这条语句.

方法2:

除了可以像上述那样捕获多个异常以外,我们还可以通过|这个符号来捕获多个异常

如果多个异常的处理方式是完全相同, 也可以写成这样:

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {

...

}

public class yichang {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //catch代码块可以捕获多个异常
        try {
            System.out.println("before");
            System.out.println(arr[100]);
            //因为此时上面的代码发生了异常,所以此时下面的代码是不会被执行的。
            System.out.println("after");
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
            System.out.println("此段代码不会执行");
            e.printStackTrace();

        }
        System.out.println("after try catch");
    }
}

  
//输出结果为
     before
     此段代码不会执行
     java.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:11)
     after try catch

代码4 也可以用一个 catch 捕获所有异常(不推荐)

public class yichang {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //也可以用一个 catch 捕获所有异常(不推荐)
        try {
            System.out.println("before");
            System.out.println(arr[100]);
            //因为此时上面的代码发生了异常,所以此时下面的代码是不会被执行的。
            System.out.println("after");
            //由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("此段代码会执行");
        }
    }
}


//输出结果
before
java.lang.ArrayIndexOutOfBoundsException: 100 at yichang.main(yichang.java:11)
此段代码会执行

由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.

代码5 finally

finally表示最后的善后工作, 例如释放资源.

scanner对象此时表示的是一种资源,资源最终要被释放

public class yichang {
    public static void main(String[] args) {
        //scanner中的close方法
        Scanner scanner = new Scanner(System.in);
        try {
            int a = scanner.nextInt();
            System.out.println(10 / a);

        } catch (ArithmeticException e) {
            e.printStackTrace();

        } finally {
            scanner.close();
            System.out.println("不管是否发生异常,finally块都会永远被执行");
        }
    }
}


//输出结果
java.lang.ArithmeticException: / by zero at yichang.main(yichang.java:13)
不管是否发生异常,finally块都会永远被执行

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

public class yichang {
    public static void main(String[] args) {
        int a=0;
        try {
            int ret=10/a;
        }catch (ArrayIndexOutOfBoundsException e){

        }finally {
            System.out.println("hhhh");
        }
    }
}

输出结果为:

hhhh
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at yichang.main(yichang.java:9) 

可以看到,此时我们并没有在catch中找到匹配的异常类型,所以catch中的语句并不会执行,但是finally中的语句是无论是否找到匹配的异常类型, finally 中的代码都会被执行到,所以最终先输出hhh,再抛出算术异常.

代码6 使用try负责回收资源

刚才在代码5中,我们使用finally来回收资源,现在还有一种等价写法, Scanner 对象在 try ( ) 中创建, 就能保证在 try 执行完毕后自动调用 Scannerclose 方法.最终在finally中也不再需要去调用close方法.

public class yichang {
    public static void main(String[] args) {
        try(Scanner scanner = new Scanner(System.in)) {
            int a = scanner.nextInt();
            System.out.println(10 / a);

        } catch (ArithmeticException e) {
            e.printStackTrace();

        } finally {
            System.out.println("不管是否发生异常,finally块都会永远被执行");
        }
    }
}

//输出结果
0
java.lang.ArithmeticException: / by zero at yichang.main(yichang.java:11)
不管是否发生异常,finally块都会永远被执行

代码7 建议finally中不要使用return语句

public class yichang {
    public static int func() {
        try {
            int a = 10;
            int ret = 10 / a;
            return ret;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            return 10;
        }
    }

    public static void main(String[] args) {
        System.out.println(func());
    }
}


//输出结果
10

原因是当我们调用func函数其实最想获得的是10/a的返回值,但是当我们在func函数中使用了finally之后,func函数的返回值变为了finally函数中return出来的值,不是我们想要的结果,所以最终输出结果不是3,而是10.所以我们并不建议在finally中使用return语句.

代码8 如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递

    在下面代码中,首先func方法并没有处理数组下标越界异常,所以此时会沿着栈向上传递到main方法,最终在main方法中找到了try catch来处理数组下标越界这个异常.

java中的异常(带你全面了解异常)_第3张图片

public class yichang {
    public static void func3() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);
    }

    public static void main(String[] args) {
        try {
            func3();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
}

//输出结果
java.lang.ArrayIndexOutOfBoundsException: 100
	at yichang.func3(yichang.java:8)
	at yichang.main(yichang.java:13)
after try catch

代码示例9 如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止(和我们最开始未使用 try catch 时是一样的)

public class yichang {
    public static void func() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);
    }

    public static void main(String[] args) {

        func();
        System.out.println("hhh");
    }
}

输出结果为

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
    at yichang.func(yichang.java:8)
    at yichang.main(yichang.java:13)

可以看到, 程序已经异常终止了, 没有执行到 System.out.println("after try catch"); 这一行. 

总结

异常处理流程

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

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

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

4:无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行). 如果上层调用者也没有处理的了异常, 就继续向上传递.

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

3.3声明和抛出异常

声明异常:使用throws关键字

抛出异常:使用throw关键字

    一般声明异常和抛出异常都是搭配使用的,一个方法执行体中抛出了异常后,要在这个方法的后面声明抛出了哪些异常,这样是为了告诉方法的调用者这个方法声明了哪些异常,好让方法的调用者根据声明的不同异常来做出相应的处理操作,下面来看代码:

public class yichang {
    public static void func(int y) throws ArithmeticException,ArrayIndexOutOfBoundsException {
        if(y==0){
            throw new ArithmeticException();
        }
        System.out.println(10/y);
    }

    public static void main(String[] args) {
        try {
            func(0);
        } catch (ArithmeticException|ArrayIndexOutOfBoundsException e) {
            System.out.println("jj");
        } finally {
            System.out.println("hh");
        }
    }
}

3.4异常小练习

第1题(单选题)

题目名称

关于Java的异常处理机制的叙述哪些正确?

题目内容

A.如果程序发生错误及捕捉到异常情况了,才会执行finally部分

B.其他选项都不正确

C.当try区段的程序发生异常且被catch捕捉到时,才会执行catch区段的程序

D.catch部分捕捉到异常情况时,才会执行finally部分

正确答案:C

第2题(单选题)

题目名称

有关下述Java代码描述正确的选项是____。

public class TestClass {

  private static void testMethod() {

     System.out.println("testMethod");

   }

  public static void main(String[] args) {

     ((TestClass)null).testMethod();

   }

}

题目内容

A.编译不通过

B.编译通过,运行异常,报NullPointerException

C.编译通过,运行异常,报IllegalArgumentException

D.编译通过,运行异常,报NoSuchMethodException

E.编译通过,运行异常,报Exception

F.运行正常,输出testMethod

正确答案:F

解析:因为testMethod方法为静态方法,是不依赖于对象的,所以最终经过类型强转后是可以正常输出的.

第3题(单选题)

题目名称

下列程序的运行结果

public void getCustomerInfo() {

    try {

      // do something that may cause an Exception

    } catch (java.io.FileNotFoundException ex) {

      System.out.print("FileNotFoundException!");

    } catch (java.io.IOException ex) {

      System.out.print("IOException!");

    } catch (java.lang.Exception ex) {

      System.out.print("Exception!");

    }

  }

题目内容

A.IOException!

B.IOException!Exception!

C.FileNotFoundException!IOException!

D.FileNotFoundException!IOException!Exception!

正确答案:A

解析:从题中我们可以看到Exception这个异常是IOException这个异常的父类,而IOException是FileNotFoundException这个异常的父类,所以从整个代码来看的话,从上到下构成了子类到父类这样一个顺序,当try中假设抛出了FileNotFoundException这个异常的话,最终只会抛出对应 catch (java.io.FileNotFoundException ex)中的语句,并不会将catch (java.io.IOException ex)和 catch (java.lang.Exception ex)这两个catch中的语句抛出。

反例:假设此时我们变化catch的顺序,那么最终会发生什么呢?来看代码吧:

public void getCustomerInfo() {

        try {

            // do something that may cause an Exception

        } catch (java.lang.Exception ex) {

            System.out.print("Exception!");

        } catch (java.io.IOException ex) {

            System.out.print("IOException!");

        } catch (java.io.FileNotFoundException ex) {

            System.out.print("FileNotFoundException!");

        }

    }

当我们变化顺序后,当try中假设抛出了FileNotFoundException这个异常的话,最终只会抛出对应 catch (java.lang.Exception ex)中的语句,并不会将catch (java.io.IOException ex)和 catch (java.lang.FileNotFoundException ex)这两个catch中的语句抛出。

原因是Exception是FileNotFoundException的父类,父类已经捕捉到这个异常了,下面的catch语句当然不用再就继续捕捉了,且不管顺序如何,构成子父类关系的catch语句也只有一个会被执行

总结:以后捕捉异常的时候,从上往下,一定注意顺序,如果最上面是父类,那么下面的捕捉语句都不会被执行,所以应该先写子类的catch语句,再写父类的catch语句。

第5题(单选题)

题目名称

下面有关JAVA异常类的描述,说法错误的是?

题目内容

A. 异常的继承结构:基类为Throwable,Error和Exception继承Throwable,RuntimeException和IOException等继承Exception

B.非RuntimeException一般是外部错误(非Error),其必须被 try{}catch语句块所捕获

C. Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形,Error不需要捕捉

D.RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须被 try{}catch语句块所捕获

正确答案:D

解析:

A:正确

B:非RuntimeException包括了Error和编译时异常,然后又加上非Error后,就只剩下了编译时异常,编译时异常是必须被try catch捕获的

C:正确

D:运行时异常不一定非要被try catch捕获,不去捕获的话便会交给JVM去处理


4.自定义异常

注意事项

1:自定义异常通常会继承自 Exception 或者 RuntimeException.

2:继承自 Exception 的异常默认受查异常(编译时异常).

3:继承自 RuntimeException 的异常默认非受查异常(运行时异常).

代码实例 

代码1:手动定义异常原因

在手动抛出异常的时候,可以说明产生这个异常的原因,在异常后面的括号内写入原因即可

public class yichang {

    public static void main(String[] args) {
        
        try {
            throw new ArithmeticException("抛出算术异常");
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
}

输出结果为:

java.lang.ArithmeticException: 抛出算术异常
    at yichang.main(yichang.java:14)

代码2:自己定义一个异常类

第一种情况:自己定义的这个异常类继承于RuntimeException

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

public class yichang {
    public static void main(String[] args) {

        try {
            throw new MyException("抛出自己定义的异常");
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

输出结果为:

MyException: 抛出自己定义的异常
    at yichang.main(yichang.java:16)

第二种情况:自己定义的这个异常类继承于Exception 

先来看两组代码:

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

public class yichang {
    public static void main(String[] args) {
        int a=10;
        if(a==10){
            throw new MyException("sss");
        }
    }
}

 运行结果为:

Exception in thread "main" MyException: sss
    at yichang.main(yichang.java:15)

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

public class yichang {
    public static void main(String[] args) {
        int a=10;
        if(a==10){
            throw new MyException("sss");
        }
    }
}

运行结果报错:截图如下 

java中的异常(带你全面了解异常)_第4张图片

 可以看到,当我们自定义的异常类继承于RuntimeException,且在主方法中并没有使用try catch捕获我们自定义的异常的时候,最终会将异常交给我们的JVM处理,因为运行时异常既可以被try catch捕获,也可以交给JVM处理。

当我们自定义的异常类继承于Exception,且在主方法中并没有使用try catch捕获我们自定义的异常的时候,最终会报错,原因是继承于Exception的异常类属于编译时异常,也就是我们的受查异常,必须被try catch捕获。

同时我们还要注意:

假如在一个函数中所抛出(throw)的异常属于编译时异常,且这些编译时异常在这个函数中并没有使用try catch进行处理,那么首先需要在函数的后面声明(throws)异常,并且在主函数中调用这个函数的时候使用try catch来处理这些编译时异常.

假如在一个函数中所抛出的异常属于编译时异常,且这些编译时异常在这个函数中使用了try catch进行处理,那么就不需要在函数的后面声明异常,并且在主函数中调用这个函数的时候直接调用即可,也不需要拿try catch进行捕获异常和处理操作.

代码示例:

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

public class yichang {
    public static void print(int a) throws MyException {
        if (a == 0) {
            throw new MyException("编译时异常");
        }
    }

    public static void main(String[] args) {
        try {
            print(0);
        } catch (MyException e) {
            System.out.println("hh");
        }
    }
}

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

public class yichang {
    public static void print(int a) {
        try {
            if (a == 0) {
                throw new MyException("编译时异常");
            }

        } catch (MyException e) {
            System.out.println("hh");
        }
    }

    public static void main(String[] args) {
        print(0);
    }
}

你可能感兴趣的:(javase基础,java)