Java基础：异常机制

异常概述

　　在Java程序运行的过程中，所有发生不正常的情况我们统称为异常。（开发过程中的语法错误和逻辑错误不叫异常）异常的出现会打断我们程序的执行过程，一旦异常出现，异常代码处的后续代码将不再执行（未处理的情况下），因此在程序的设计过程中我们需要尽量避免并且妥善的处理异常发生的情况。Java异常处理机制也秉承着Java面向对象的设计思想，所有的异常都是以类的形式存在的（可以参考下文的异常体系结构），除了内置的异常外我们还可以手动的自定义异常。

异常的分类

在Java语言体系中，异常可以分为两大类

　　1、java.lang.Error: Java虚拟机无法解决的严重异常，例如jvm系统内部错误，资源耗尽等情况。一般我们不会设计相应的代码去捕捉这种异常，原因在于即使捕捉到了也无法给出相应的处理。

public class ErrorTest {
    public static void main(String[] args) {
        main(args);//java.lang.StaticOverflowError（栈溢出异常）
    }
}

　　2、java.lang.Exception:因编程错误或者偶然因素导致的一般性问题，比如空指针异常，数组角标越界异常。对于这些异常我们可以轻易的捕捉并且进行处理

public class ExceptionTest {
    public static void main(String[] args) {
        int[] a = new int[5];
        a[5] = 10;
        System.out.println("a[5] = " + a[5]);//java.lang.ArrayIndexOutOfBoundsException(数组角标越界)
    }
}

无论是Error异常还是Exception异常都继承了java.lang.Throwable类

编译时异常和运行时异常（都属于Exception异常）

　　Java程序在执行的过程中分为两个过程，一是先将源文件编译成.class字节码文件，二是在内存中加载，运行字节码文件。在编译的过程中发生的异常我们称之为编译时异常，在运行时发生的异常我们称之为运行时异常。对于编译时异常我们也可以称之为受检（checked）异常，对于运行时异常我们称之为非受检（unckecked）异常。无论是编译时异常还是运行时异常都是属于Exception异常。看下面的异常体系结构图，对于蓝色的就是运行时异常，红色的是编译时异常。

异常类的继承体系

常见的运行时异常

1、数组角标越界

public class ExceptionTest {
    public static void main(String[] args) {
        int[] a = new int[5];
        a[5] = 10;
        System.out.println("a[5] = " + a[5]);//java.lang.ArrayIndexOutOfBoundsException(数组角标越界)
    }
}

2、类型转换异常

public class ExceptionTest {
    public static void main(String[] args) {
       Object object = new Date();
       //Exception in thread "main" java.lang.ClassCastException: java.util.Date cannot be cast to java.lang.String
       String str = (String) object;
    }
}

3、空指针异常

public class ExceptionTest {
    public static void main(String[] args) {
       int[] a = null;
       //Exception in thread "main" java.lang.NullPointerException
        System.out.println("a[2] = " + a[2]);
    }
}

其他的还有很多，比如NumberFormatException异常、InputMisMacthException异常等....

常见的编译时异常

FileNotFoundException

ClassNotFoundException

SQLException

NoSuchFieldException

NoSuchMethodException

ParseException

异常的处理方式一：try...catch...finally

　　try...catch..finally是在开发中经常使用的处理异常的方式之一，使用try将可能出现的代码块包裹，一旦出现了异常就会生成一个相应的异常类，该异常类与多个catch中对应的异常类参数进行匹配，如果匹配成功就执行相应的catch代码块中的代码，执行完成就跳出该try..catch结构（不执行其余catch），如果有finally代码块会继续执行finally里面的代码。该种写法的好处是可以比较灵活的运用，同时在使用catch捕获到异常之后我们还可以进行一些其他操作。

try...catch...finally模板

  try{
     //可能出现异常的代码
  }catch (Exception e){
     //捕获到异常之后进行的操作
  }finally {
     //一定会执行的代码
  }

try...catch...finally注意事项

1、try代码块是不能省略的（catch和finally如果想要使用需要搭配try，反之亦然）

2、try代码块不能单独出现，要么与catch代码块搭配（此时可以捕获到出现的异常在catch代码块中进行处理），要么与finally代码块搭配（此时不能捕获异常，但是finally代码块里的内容可以执行）

 //try...catch搭配
        try{
            int a = 10 / 0;
            System.out.println("a = " + a);
        }catch (Exception e){
            System.out.println("代码出现异常");
        }
输出结果：
代码出现异常

/**************************************/

 //try...finally搭配
        try {
            int a = 10 / 0;
        }finally {
            System.out.println("一定会执行的代码");
        }
输出结果：
一定会执行的代码
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.cangfengwork.exercise.throwable.ExceptionTest.main(ExceptionTest.java:21)

3、catch代码块可以出现多次，但是捕获的异常大小需要从小到大，简单来说就是前面的catch捕获的异常类需要是后面catch捕获的异常类的子类（如果前后没有子父类关系则不要求顺序）

 //try搭配多个catch
        try{
            int a = 10 / 0;
            System.out.println("a = " + a);
        }catch (ArithmeticException e){
            System.out.println("出现了ArithmeticException异常");
        }catch (Exception e){
            System.out.println("出现了异常");
        }
输出结果：
出现了ArithmeticException异常

/*****************************************************/
//try搭配多个catch
        try{
            int a = 10 / 0;
            System.out.println("a = " + a);
        }catch (Exception e){
            System.out.println("出现了ArithmeticException异常");
        }catch (ArithmeticException e){
/*此处编译报错，因为ArithmeticException异常是Exception异常的子类，应放在前面*/
            System.out.println("出现了异常");
        }

 4、在try代码块中声明的变量一旦出了该代码块则不能被调用

        try{
            int a = 10 / 0;
            System.out.println("a = " + a);
        }catch (Exception e){
            System.out.println("出现了ArithmeticException异常");
        }
        System.out.println("a = " + a);//编译报错：Cannot resolve symbol 'a'

5、finally代码块中的内容一定会被执行，如果一个方法需要返回值且finally中写了return，则返回结果一定是finally中的结果

 public static void main(String[] args) {
       int a = test();
        System.out.println("a = " + a);
    }

    public static int test(){
        try{
            System.out.println("try...........");
            int a = 10 / 0;
            return 1;
        }catch (Exception e){
            System.out.println("catch...........");
            return 2;
        }finally {
            System.out.println("finally...........");
            return 3;
        }
    }

输出结果：
try...........
catch...........
finally...........
a = 3

6、try...catch...finally是可以嵌套使用的（可能我们在catch中也可能会出现异常）

  public static void main(String[] args) {
       int a = test();
        System.out.println("a = " + a);
    }

    public static int test(){
        try{
            System.out.println("try...........");
            int a = 10 / 0;
            return 1;
        }catch (Exception e){
            System.out.println("catch...........");

            try{
                System.out.println("内部try............");
                 int[] a = new int[10];
                System.out.println("a[10] = " + a[10]);
                return 2;
            }catch (ArrayIndexOutOfBoundsException e1){
                System.out.println("内部catch.......");
//                e1.printStackTrace();//打印异常
                return 4;
            }finally {
                System.out.println("内部finally.......");
                return 5;
            }
        }finally {
            System.out.println("finally...........");
            return 3;
        }
    }

输出结果：
try...........
catch...........
内部try............
内部catch.......
内部finally.......
finally...........
a = 3

7、在日常开发中，我们通常使用try...catch...finally来处理编译时异常，但是无法解决运行时异常（通常运行时异常需要我们修改代码），换句话说，我们可以使用try...catch...finally将编译时异常延时到运行时出现

异常处理方式二：throws + 异常类型

　　该方法是异常处理的第二种方法，也是Java程序默认的异常处理机制。通常写在方法的声明处，指出该方法在执行时可能会出现的异常类型。同样的，当方法体内出现了异常代码，会在异常代码处生成一个对应的异常类对象，一旦满足方法声明处的异常类型就会被抛出。而异常代码处后续的代码不再执行。

 public static int test() throws FileNotFoundException {
        File file = new File("hello.txt");
        FileInputStream fileInputStream = new FileInputStream(file);//一旦此处出现异常，下面的输出语句将不再执行
        System.out.println("后续代码..........");
        return 1;
    }

与try...catch...finally处理异常的方式对比，throws并没有真正的将异常处理掉，仅仅是将异常抛给方法的调用者，由方法调用者使用try...catch解决异常或者继续抛给上方的方法调用者 

当子类重写父类的方法时，子类所抛出的异常范围应当不大于比父类抛出异常范围

　　在子类重写父类的方法时，该方法可能会抛出异常，这个时候子类要么使用try...catch将异常进行处理，要么将异常抛给方法调用者，此时子类重写的方法抛出的异常范围应当不大于比父类抛出的异常范围

public class ExceptionTest {
    public static void main(String[] args) {
        ExceptionTest exceptionTest = new ExceptionTest();
        exceptionTest.test(new Sub());
    }

    public void test(Super s){
        try {
            s.superMethod();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

class Super{
    public void superMethod() throws IOException {
        System.out.println("superMethod......");
    }
}

class Sub extends Super{
    @Override
    public void superMethod(){

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

}

 

　　原因：看上述代码我们可以知道，在test方法中我们对父类中的方法出现的异常进行了处理，在main方法中我们使用了多态传递了一个子类的对象，如果此时子类中重写的方法所抛出的异常类型为Exception（也就是说比父类方法抛出的异常范围大）那么很显然，在test方法中无法匹配到catch代码块，异常也就无法进行处理

当然，在开发工具中，我们如果不遵守这个规则，编译的时候会不通过

class Sub extends Super{
    @Override
    public void superMethod() throws Exception{//此时编译不通过：'superMethod()' in 'com.cangfengwork.exercise.throwable.Sub' clashes with 'superMethod()' in 'com.cangfengwork.exercise.throwable.Super'; overridden method does not throw 'java.lang.Exception'

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

}

 

在开发中，如果父类中的方法没有使用throws抛出异常，那么子类重写的方法也不能使用throws，只能使用try...catch来处理异常

手动抛出异常（throw的用法）

　　在上文的介绍中，无论是1try...catch还是throws都是处理异常的方法，而throw是手动的生成异常的方法。throw和throws是完全的两个概念，一定不要被他们相似的外表迷惑！！！

public class ThrowTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        test(list);
    }

    public static void test(List<Integer> flourList) {
        /**
         * 输入十个数字，范围在0~100之间，并将他们存到集合中，如果输入错误将抛出异常！！
         */
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 10; i++) {
            int a = scanner.nextInt();
            if (a < 10 && a > 0){
                flourList.add(a);
            }else {
                throw new RuntimeException("第【"+(i+1)+"】个数背错了，准备挨打！！！");
            }
        }
    }
}

 

输出结果：

1 2 1 -1 2 3 4 -1 -4 -10
Exception in thread "main" java.lang.RuntimeException: 第【4】个数背错了，准备挨打！！！
    at com.cangfengwork.exercise.throwable.ThrowTest.test(ThrowTest.java:28)
    at com.cangfengwork.exercise.throwable.ThrowTest.main(ThrowTest.java:15)

throw和throws的区别

　　throws是处理异常的方法，它写在方法的声明处，用来将方法体内部可能出现的异常抛出，而throw是手动创建异常对象的方法，它写在方法体内部的任意位置。一般来说，throw后面跟的是运行时异常类的对象（不做要求，可以跟其他异常类对象），而throws后面跟的是Exception异常类的对象。

自定义异常类

　　在开发的过程中，我们可能会遇到各种各样的异常（此处的异常泛指不符合我们要求的数据，比如要求输入正整数但是用户输入了负数），而Java并没有提供相应的异常类供我们使用，这个时候我们就可以自定义一个异常类来处理类似的情况。

定义自定义异常类：

public class MyException extends RuntimeException{
    //提供序列号，一般来说，继承的类有两种，一种是Exception，一种是RunTimeException。继承Exception需要我们使用异常处理的两种方式进行处理，而RunTimeException则不需要
    static final long serialVersionUID = -7034897190745766939L;

    //提供无参构造器
    public MyException(){

    }
    //提供带参数的构造器
    public MyException(String message){
        super(message);//使用父类的带参构造器
    }
}

使用：

 public static void test(List<Integer> flourList) {
        /**
         * 输入十个数字，范围在0~100之间，并将他们存到集合中，如果输入错误将抛出异常！！
         */
        Scanner scanner = new Scanner(System.in);
        int a = 0;
        for (int i = 0; i < 10; i++) {
            a = scanner.nextInt();
            if (a < 10 && a > 0){
                flourList.add(a);
            }else {
                throw new MyException("第【"+(i+1)+"】个数背错了，准备挨打！！！");
            }
        }
        System.out.println("a = " + a);
    }