java 的异常处理

异常处理

异常的概述

在程序中，异常是程序员可能没有想到的而发生的各种情况，也可能是程序员可控范围的环境因素产生。例如用户的坏数据，和试图打开一个根本不存在的文件。在java中，这种在程序运行是可能出现的一些错误成为异常。异常是一个在程序执行期间发生的事件，他中断了正在执行的程序的正常指令流。

例如 0 是不可以作为除数的，如果我们在程序中将 0 作为除数，那么程序就会报错。那么我们就可以用异常来处理他。

在项目中创建一个 Baulk 类，在方法中定义 int 类型的变量,将 0 作为算术表达式赋值给该变量。

public class Baulk {
    public static void main(String[] args) {
        int result = 3 / 0;
        System.out.println(result);
    }
}

当我们运行的时候，这个程序就会报错。这是显而易见的。java 是一门面向对象的编程语言，因此异常在java中，也是作为类的实例的形式出现的。当某一个方法中发生错误时，这个方法会创建一个对象，并且把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理的代码与程序的逻辑分离，即在编写代码主流程的同时在其他地方处理异常。

异常地抛出和捕获

为了保证程有效地执行，需要对抛出的异常进行相应的处理。

如果抛出异常之后我们不做处理，程序就会被终止。

例如，将一个字符串转换为整型，可以通过 Integer 类的 parseInt() 方法实现。但如果该字符串不是数字形式的， parseInt() 方法就会抛出异常，程序将在出现异常的位置终止，不再执行下面的语句。

public class Thundering {
    public static void main(String[] args) {
        String name = "lili";
        System.out.print(name + "的年龄是：");
        int age = Integer.parseInt("20L");
        System.out.println(age);
    }
}

我们在运行这个代码之后会发想，在打印了第一条打印语句的内容之后，程序就抛出了异常，程序也随之终止。

由此可以看出程序是在数据转换的时候终止的。

捕捉异常

在 java 语言中，异常的捕获结构是由 try,catch 和 finally 组成的。其中，try 语句快存放的是可能发生异常的语句；catch 在 try 之后，用来激发被捕获的异常；finally 语句块是异常处理结构的最后执行部分，无论 try 语句块中的代码如何退出，都讲执行 finally 语句块。

try {
    // 程序代码块
} catch(Exceptiontype1 e) {
    // 对 Exceptiontype1 的处理
} catch (Exceptiontype2) {
    //对 Exceptiontype2 的处理
}
......
finally {
    // 程序代码块
}

那么，我们该如何使用它呢？见下面代码：

public class Take {
    public static void main(String[] args) {
        try {
            String name = "lili";
            System.out.println(name + "年龄是：");
            int age = Integer.parseInt("20L");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("异常处理");
        }
        System.out.println("over");
    }
}

运行结果：

lili年龄是：
异常处理
over
java.lang.NumberFormatException: For input string: "20L"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at demo.Take.main(Take.java:11)

由运行结果可以看出，程序仍然可以输出最后的信息，并没有因为程序的异常而终止。

在上面的例子中，将可能出现异常的代码用 try-catch 语句进行处理，当 try 语句块中的语句发生异常时， 程序就会跳到 catch 语句块中执行，执行完 catch 语句块中的代码后，将继续执行 catch 后的其他代码，而不会执行 try 语句块中发生异常语句后面的代码。

finally 语句块

完整的异常处理语句一定要包含 finally 语句，无论程序中有无异常发生，并且无论之前的 try-catch 语句是否顺利执行完毕，都会执行 finally 语句。

但是一下四种特殊情况下，finally 快不会被执行。

• 在 finally 语句块中发生了异常
• 在前面的代码中使用了 System.exit() 退出程序。
• 程序所在的线程死亡。
• 关闭了 cpu

java 中常见的异常

异常类	说明
ClassCasException	类型装换异常
ClassNotFoundException	未找到相应类异常
ArithmeticException	算术异常
ArrayIndexOutOfBoundsException	数组下标越界异常
arrayStoreException	数组中包涵不兼容的值抛出异常
SQLException	操作数据库异常类
NullPointerException	空指针异常
NoSuchFieldException	字段为找到异常
NoSuchMethodException	方法为找到异常
NumberFormatException	字符串转换为数字抛出异常
NegativeArraySizeException	数组元素个数
StringIndexOutOfBoundsException	字符串索引超出范围抛出的异常
IOException	输入输出异常
IllegalAccessException	当应用程序试图使用 Class 类中的 newInstance() 方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
EOFException	文件已结束异常
FileNotFoundException	文件未找到异常

自定义异常

我们除了使用 java 自带的异常类之外，还可以自己定义异常类。在方法中通过 throw 关键字抛出异常。

在项目中 MyException 类，该类继承 Exception 类。

public class MyException extends Exception {
    String message;
    public MyException(String errorMessage) {
        this.message = errorMessage;
    }
    @Override
    public String getMessage() {
        return this.message;
    }
}

字符串 ErrorMessage 是要输出的错误信息。若想抛出用户自定义的异常对象，要使用 throw 关键字。

public class Tran {
    static int avg(int number1, int number2) throws MyException {
        if (number1 < 0 || number2 < 0) {
            throw new MyException("不可以使用负数");
        }
        if (number1 > 100 || number2 > 100) {
            throw new MyException("数值太大");
        }
        return (number1 + number2) / 2;
    }

    public static void main(String[] args) {
        try {
            int result = avg(102, 111);
            System.out.println(result);
        }catch (MyException e ) {
            System.out.println(e);
        }
    }
}

运行结果：

demo.MyException: 数值太大

在方法中抛出异常

如果我们在某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用 throws 、 throw 关键字在方法中抛出异常。

使用 throws 关键字抛出异常

throws 关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分割。

例如我们在一个方法中抛出一个异常

public class Shoot {
    static void pop() throws NegativeArraySizeException{
        int[] arr = new int[-3];
    }

    public static void main(String[] args) {
        try {
            pop();
        } catch (NegativeArraySizeException e) {
            System.out.println("pop()方法抛出的异常");
        }
    }
}

使用 throw 关键字抛出异常

public class Captor {
    static int quotient(int x, int y) throws MyException {
        if (y < 0) {
            throw new MyException("除数不能是负数");
        }
        return x / y;
    }

    public static void main(String[] args) {
        try {
            int result = quotient(3, -1);
        } catch (MyException e) {
            System.out.println(e);
        } catch (ArithmeticException e) {
            System.out.println(e);
        } catch (Exception e) {
            System.out.println("程序发生了其他的异常");
        }
    }
}

上面的例子使用了多个 catch 语句来捕捉异常。如果调用 quotient(-3, 1) 方法，将发生 MyException 异常，程序将跳转到 catch(MyException),总之发生了对于的异常就会触发对应的 catch；如果发生了没在代码中列出来的异常，那么就会用 catch (Exception e) 来捕捉异常。