Java的异常处理机制

一、什么是java异常？

• java中所有错误的超类为：Throwable。其下有两个子类：Error 和 Exception。
• Error的子类描述的都是系统错误，比如虚拟机内存溢出。
• Exception的子类描述的都是程序，比如空指针，下标越界等。
• 通常我们程序中处理的异常都是Exception。

Java异常类的层次结构图：

Java所有异常类都是 Throwable的子类，它包括Java异常处理的两个重要子类：Error和Exception。

Error：Error及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，是程序无法处理的错误，这类错误比较严重。这类的大多数错误与代码编写者执行的操作无关，如，运行代码时，JVM（Java虚拟机）出现的问题，例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。 这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。 

Exception：可以通过捕捉处理使程序继续执行，是程序自身可以处理的异常，也称为非致命性异常类。根据错误发生原因可分为RuntimeException异常和除RunTimeException之外的异常，如IOException异常。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常 NullPointerException、ArithmeticException 和 ArrayIndexOutOfBoundException。 

异常中常用的方法

​​​​​​​​​​​​try {
            String str = "abc";
            System.out.println(Integer.parseInt(str));

 } catch (NumberFormatException e) {
            //异常最常用的方法,用于将当前错误信息输出到控制台
            e.printStackTrace();

            //获取错误消息.记录日志的时候或提示给用户可以使用它
            String message = e.getMessage();
            System.out.println(message); 

}

Java异常可以分为可检测异常，非检测异常：

• 可检测异常：可检测异常经编译器验证，它是编译器要求必须处理的异常，这类异常的发生在一定程度上是可以预计的，而且这类异常一旦发生，就必须采用某种方式进行处理。除了RuntimeException及其子类以外的其它异常类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，出现这种异常，要么用try-catch语句捕捉它，要么用throws语句声明抛出它，否则编译不通过（不捕捉这个异常，编译器就通不过，不允许编译）。

• 非检测异常：非检测异常不遵循处理或者声明规则。在产生此类异常时，编译器不要求强制处理的异常，包括运行时异常（RuntimeException与其子类）和错误（Error），编译器不会检查是否已经解决了这样一个异常。

RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。

常见的RuntimeException子类：

• IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数

• NullPointerException：当应用程序试图在需要对象的地方使用 null 时，抛出该异常

• ArrayIndexOutOfBoundsException：当使用的数组下标超出数组允许范围时，抛出该异常

• ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常

• NumberFormatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。

Exception 异常

Exception 异常又可分为两大类：运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。        

• 运行时异常：RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不可查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生

运行时异常的特点：Java编译器不会检查它，也就是说，当程序中出现这类异常时，也会编译通过。

• 非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

异常处理机制中的try-catch

package demo;
/**
 * 异常处理机制中的try-catch
 * 语法:
 * try{
 *     可能出现异常的代码片段
 * }catch(XXXException e){
 *     try中出现XXXException后的处理代码
 * }
 * try语句块不能独立存在，后面必须跟catch语句块或finally语句块
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        try {
//            String line = null;
//            String line = "";
            String line = "abc";
            //当JVM执行程序出现了某个异常时就会实例化这个异常并将其抛出
            //如果该异常没有被异常处理机制控制，则JVM会将异常隐式抛出当方法外(这里是main方法外)
            System.out.println(line.length());
            System.out.println(line.charAt(0));
            System.out.println(Integer.parseInt(line));
            //若try语句块中某句话出错了，则剩下的代码都不会执行!
            System.out.println("!!!!!!!!!!!!!!!!");
//        }catch(NullPointerException e){
//            System.out.println("出现了空指针!");
//        //catch可以定义多个，当try中不同的异常有不同处理办法时可分开捕获并处理
//        }catch(StringIndexOutOfBoundsException e){
//            System.out.println("出现了下标越界!");
            //若某些异常的处理方式相同时，可以合并在一个catch来处理
        }catch(NullPointerException|StringIndexOutOfBoundsException e){
            System.out.println("出现了空指针或下标越界并处理了!");
            //可以在下面catch超类异常来捕获并处理这一类异常。
        }catch(Exception e){
            System.out.println("反正就是出了个错");
        }
        System.out.println("程序结束了");
    }
}

异常处理机制中的 finally

• finally块定义在异常处理机制中的最后一块。它可以直接跟在try之后，或者最后一个catch之后。

• finally可以保证只要程序执行到了try语句块中，无论try语句块中的代码是否出现异常，最终finally都必定执行。

• finally通常用来做释放资源这类操作。

package demo;
/**
 * 异常处理机制中的finally
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        try{
            String line = null;
            System.out.println(line.length());
            return;
        }catch(Exception e){
            System.out.println("出错了!");
        }finally{
            System.out.println("finally中的代码执行了!");
        }
        System.out.println("程序结束了!");
    }
}

IO操作时的异常处理机制应用

package demo;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 使用java.io.BufferedReader按行读取文本数据
 */
public class Test {
    public static void main(String[] args) throws IOException {
        //将当前源程序(Test.java)读取出来并输出到控制台上
//        FileInputStream fis = new FileInputStream("./src/demo/Test.java");
        //读取fos.daat文件中的数据
        FileInputStream fis = new FileInputStream("fos.dat");
        InputStreamReader isr = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(isr);
        String line;
        /*
            BufferedReader提供了一个读取一行字符串的方法:
            String readLine()
            该方法会返回一行字符串，返回的字符串不含有最后的换行符。
            当某一行是空行时(该行内容只有一个换行符)则返回值为空字符串。
            如果流读取到了末尾，则返回值为null。
         */
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();
    }
}

IO操作中自动关闭特性

JDK7之后，java提供了一个新特性：自动关闭。指在IO操作中可以更简洁的使用异常处理机制完成最后的close操作。

语法：

try(

        定义需要在finally中调用close()方法关闭的对象。

){

        IO操作

}catch(XXXException e){

        .....

}

注：

        该语法中可在try的"()"中定义的并初始化的对象必须实现了java.io.AutoCloseable接口，否则编译不通过。

package demo;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * IO操作中自动关闭特性
 */
public class Test {
    public static void main(String[] args) {
        try(
                FileInputStream fis = new FileInputStream("fos.dat");
                InputStreamReader isr = new InputStreamReader(fis);
                BufferedReader br = new BufferedReader(isr);
        ){
            String line;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();//向控制台输出当前异常的错误信息
        }
    }
}

注：

上述代码是编译器认可的，而不是虚拟机。编译器在编译上述代码后会在编译后的class文件中改回成try-catch-finally的代码格式。

抛出异常的方法：throw 和 throws

• throw关键字：

throw通常用在方法体中或者用来抛出用户自定义异常，并且抛出一个异常对象。程序在执行到throw语句时立即停止，如果要捕捉throw抛出的异常，则必须使用try-catch语句块或者try-catch-finally语句。

package exception;
/**
 * throw关键字
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }
    public void setAge(int age){
         if (age<0 || age>100){
//            throw new RuntimeException("年龄不合法！");
             /*
                 当我们使用throw主动对外抛出异常时，除了Runtimeption之外
                 其他异常抛出时必须在方法上使用throws声明该异常的抛出
              */
             try {
                 /*
                     程序在执行到throw语句时立即停止，如果要捕捉throw抛出的异常，
                     则必须使用try-catch语句块或者try-catch-finally语句。
                 */
                 throw new IllegalAgeException("年龄不合法");
             } catch (IllegalAgeException e) {
                 e.printStackTrace();
             }
         }
        this.age = age;
    }
}

package demo;

import exception.Person;
/**
 * throw关键字，用来对外主动抛出一个异常。
 * 通常下面两种情况我们主动对外抛出异常:
 * 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 * 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
 */
public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
        System.out.println("此人年龄:"+p.getAge());
    }
}

输出结果： 

• throws关键字

通常被用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔。throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

注意，永远不应当在main方法上使用throws!

package exception;
/**
 * 测试异常的抛出
 */
public class Person {
    private int age;
    public int getAge() {
        return age;
    }
    /**
     * 当一个方法中使用throw抛出一个非RuntionExeption的异常时，就要在该方法上
     * 使用throws声明这个异常的抛出。此时调用该方法的代码就必须处理这个异常，否
     * 则编译不通过。
     */
    public void setAge(int age) throws Exception {
         if (age<0 || age>100){
//            throw new RuntimeException("年龄不合法！");
             //使用throw对外抛出一个异常
//            throw new RuntimeException("年龄不合法!");
             //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
             throw new Exception("年龄不合法");
        }
        this.age = age;
    }
}

自定义异常

自定义异常通常用来定义那些业务上的异常问题。

定义自定义异常需要注意以下问题:

• 异常的类名要做到见名知义

• 需要是Exception的子类

• 提供超类异常提供的所有种类构造器

package exception;
/**
 * 非法的年龄异常
 *
 * 自定义异常通常用来说明业务上的错误.
 * 自定义异常要注意以下问题:
 * 1:定义的类名要做到见名知义
 * 2:必须是Exception的子类
 * 3:提供Exception所定义的所有构造方法
 */
public class IllegalAgeException extends Exception{
    public IllegalAgeException() {
    }
    public IllegalAgeException(String message) {
        super(message);
    }
    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
    }
    public IllegalAgeException(Throwable cause) {
        super(cause);
    }
    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

package exception;
/**
 * 测试异常的抛出
 */
public class Person {
    private int age;
    public int getAge() {
        return age;
    }

    /**
     * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
     */
    public void setAge(int age) throws IllegalAgeException {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
//            throw new Exception("年龄不合法!");

            //抛出自定义异常
            throw new IllegalAgeException("年龄超范围:"+age);
        }
        this.age = age;
    }
}

package exception;

/**
 * throw关键字，用于主动对外抛出一个异常
 */
public class ThrowDemo {
    public static void main(String[] args){
        System.out.println("程序开始了...");
        try {
            Person p = new Person();
            /*
                当我们调用一个含有throws声明异常抛出的方法时,编译器要求
                我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
                1:使用try-catch捕获并处理异常
                2:在当前方法上继续使用throws声明该异常的抛出
                具体用哪种取决于异常处理的责任问题
             */
            p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
            System.out.println("此人年龄:"+p.getAge()+"岁");
        } catch (IllegalAgeException e) {
            e.printStackTrace();
        }
        System.out.println("程序结束了...");
    }
}

总结:

异常处理机制是用来处理那些可能存在的异常，但是无法通过修改逻辑完全规避的场景。
​​​​​​​而如果通过修改逻辑可以规避的异常是bug，不应当用异常处理机制在运行期间解决！应当在编码时及时修正。

​​​​​​​