Java异常处理机制

Java异常处理机制

​ 异常机制已经成为判断一门编程语言是否成熟的标准，Java作为一门使用广泛、广受欢迎的编程语言，必有其完

备成熟的异常处理机制,保证程序的鲁棒性。

一. Java异常概述：

​ Java的异常分为两种，checked异常（编译时异常）和RuntimeException（运行时异常）。

​ 其中checked异常都是可以在编译阶段被发现和处理的异常，编译器强制要求处理这类异常，否则程序将不能

被编译。要捕获编译期异常，一定要在try块中显式抛出了该异常。checked异常表明了Java中没有完善处理的代码

根本不会被执行，体现了java的严谨性。常见checked异常有IOException、SQLException等。

​ RuntimeException是在运行期才处理的异常，一般因为程序中有错误或考虑情况不完善，需要修改代码，例

如对参数进行非0判断和对字符串进行非空判断等。RuntimeException在编译期不强制处理，运行期JVM将自动检

测抛出。常见RuntimeException 有 ArrayIndexOutOfBoundsException、ArithmeticException、

NullPointerException等。

二. Java异常处理

​ Java异常机制主要依赖于try、catch、finally、throw、throws五个关键字和自定义异常。

（一）throw、throws用法

1.throw：用于抛出一个实际的异常，可以单独作为语句使用，抛出一个具体的异常对象,格式为throw new 异常类

构造方法，如throw new Exception()；抛出异常后使用try-catch捕获异常或使用throws声明异常；

​ 2.throws：用在方法签名中，用于声明该方法可能抛出的异常，可以声明多种异常类型，用逗号分开即

可；子类覆盖父类，子类不能声明抛出父类范围更大的异常方法；可以层层抛出异常，即catch中，再次用throw

抛出异常。

（二）try、catch、finally用法

​ 1.try：它里面放置可能引发异常的代码，用于发现异常；try块中任何一条语句发生了异常，下面的代码

将不会被执行，程序将跳转到异常处理代码块中，即catch块。

​ 2.catch：把抓到的类型匹配的异常捕获，catch语句必须紧跟着try语句之后，后面对应异常类型和一个代

码块，用于表明该catch块用于处理这种类型的代码块，可以有多个 catch块分别捕获不同类型的异常，注意要从

子类往父类的顺序写，否则有编译错误。

​ 3.finally：无论有无异常，异常机制总是保证finally块总是被执行。只有finally块执行完成之后，才会回来

执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不

会跳回执行，直接停止。

​ 4.基本语法格式：try{

                     可能会发生异常的代码

​ }catch(异常类型引用名){

                     异常处理代码

​ }finally{

​ 必须执行代码

​ }

​ 5.搭配使用情况：（1） try+catch 可以有多个catch；

​ （2）try+catch+finally 可以有多个catch，1个finally；

​ （3）try+finally ，往往结合后续throws使用。

##### 程序实例：

import java.io.IOException;
/**
 *1.异常处理机制：try+catch+finally、throw、throws用法，
 *2.了解有无异常时，程序运行的先后顺序
 */
public class ThrowException {

    public static void checkedException(int i) {
        System.err.println("1.");
        try {
            System.err.println("2.");
            throwException(i);
            System.err.println("4.");
        } catch (RuntimeException e) {//注意catch顺序
            System.err.println("5.1");
            e.printStackTrace();
            System.err.println("6.1");
        } catch (IOException e) {
            System.err.println("5.2");
            e.printStackTrace();
            System.err.println("6.2");//System.err与System.out线程不同，统一用err
        } catch (Exception e) {
            System.err.println("5.3");
            e.printStackTrace();
            System.err.println("6.3");
        } finally {
            System.err.println("异常处理结束");
        }
    }

    public static void throwException(int i) throws Exception {
        System.err.println("3.");
        if (i > 20) {
            throw new RuntimeException("RuntimeException");
        }
        if (i > 5) {
            throw new IOException("IOException");
        }
        if (i < 0) {
            throw new Exception("Exception");
        }
    }

    public static void main(String[] args) {
        System.err.println("0.当有异常1时：");
        checkedException(22);
        System.err.println("0.当有异常2时：");
        checkedException(6);
        System.err.println("0.当有异常3时：");
        checkedException(-2);
        System.err.println("0.当没有异常时：");
        checkedException(3);

    }

}

（三）自定义异常

​ 1.概念：自定义异常就是自己定义的异常类，是Exception直接或间接的子类，满足实际项目对异常的需求；

​ 2.自定义异常的定义：定义一个类并继承Exception或其子类，实际项目中常继承runtimeException，而非

checekd异常类，以便于减少代码变动时的修改；同时自定义异常类中往往不写其他方法，只重载需要使用的构造

方法:

​ public class 异常类名 extends Exception{

    public 异常类名(String message){

        super(message);

}

}

3.使用自定类的步骤：（1）创建自定义异常类

（2）在方法中通过throw 关键字抛出自定义异常

（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理，否则在方法的声明处通过throws关键字声明该异常

（4）调用throws声明该异常的方法时，使用try catch捕获自定义的异常类型，并在catch中进行处理

程序实例

/**
 *自定义异常CustomException
 */
public class CustomException extends Exception{
  public CustomException(String Error){
    super(Error);
  }
}

/**
 *自定义异常处理，及处理顺序
 */

public class ThrowCustomException {

    public static void checkedException(int i) {
        System.err.println("1.");
        try {
            System.err.println("2.");
            throwException(i);
            System.err.println("4.");
        } catch (CustomException e) {//注意catch顺序
            System.err.println("5.1");
            e.printStackTrace();
            System.err.println("6.1");
        } catch (Exception e) {//注意catch顺序
            System.err.println("5.2");
            e.printStackTrace();
            System.err.println("6.2");
        }finally {
            System.err.println("异常处理结束");
        }
    }

    public static void throwException(int i) throws Exception {
        System.err.println("3.");
        if (i > 20) {
            throw new CustomException("数值太大");
        }
        if (i < 0) {
            throw new CustomException("不能使用负数");
        }
    }

    public static void main(String[] args) {
        System.err.println("0.当有数值太大异常时：");
        checkedException(22);
        System.err.println("0.当无异常时：");
        checkedException(6);
        System.err.println("0.当有不能使用负数异常时：");
        checkedException(-2);


    }

}