java异常处理机制
Java 中的异常（Exception）又称为例外，是一个在程序执行期间发生的事件，它中断正在执行的程序的正常指令流。为了能够及时有效地处理程序中的运行错误，必须使用异常类。

异常简介
在程序中，错误可能产生于程序员没有预料到的各种情况，或者超出程序员可控范围的环境，例如用户的坏数据、试图打开一个不存在的文件等。为了能够及时有效地处理程序中的运行错误，Java 专门引入了异常类。

例 1
为了更好地理解什么是异常，下面来看一段非常简单的 Java 程序。下面的示例代码实现了允许用户输入 1~3 以内的整数，其他情况提示输入错误。

复制代码
package ch11;
import Java.util.Scanner;
public class TestO1
{

public static void main(String[] args)
{
    System.out.println("请输入您的选择：（1~3 之间的整数）");
    Scanner input=new Scanner(System.in);
    int num=input.nextInt();
    switch(num)
    {
        case 1:
            System.out.println("one");
            break;
        case 2:
            System.out.println("two");
            break;
        case 3:
            System.out.println("three");
            break;
        default:
            System.out.println("error");
            break;
    }
}

}
复制代码

正常情况下，用户会按照系统的提示输入 1~3 之间的数字。但是，如果用户没有按要求进行输入，例如输入了一个字母“a”，则程序在运行时将会发生异常，运行结果如下所示。

复制代码
请输入您的选择：（1~3 之间的整数）
a
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Unknown Source)
at java.util.Scanner.next(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at text.text.main(text.java:11)
复制代码
异常产生的原因及使用原则
在 Java 中一个异常的产生，主要有如下三种原因：

Java 内部错误发生异常，Java 虚拟机产生的异常。
编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。这种异常称为未检査的异常，一般需要在某些类中集中处理这些异常。
通过 throw 语句手动生成的异常，这种异常称为检査的异常，一般用来告知该方法的调用者一些必要的信息。

Java 通过面向对象的方法来处理异常。在一个方法的运行过程中，如果发生了异常，则这个方法会产生代表该异常的一个对象，并把它交给运行时的系统，运行时系统寻找相应的代码来处理这一异常。

我们把生成异常对象，并把它提交给运行时系统的过程称为拋出（throw）异常。运行时系统在方法的调用栈中查找，直到找到能够处理该类型异常的对象，这一个过程称为捕获（catch）异常。

Java 异常强制用户考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应处理。编写代码处理某个方法可能出现的异常，可遵循如下三个原则：

在当前方法声明中使用 try catch 语句捕获异常。
一个方法被覆盖时，覆盖它的方法必须拋出相同的异常或异常的子类。
如果父类抛出多个异常，则覆盖方法必须拋出那些异常的一个子集，而不能拋出新异常。
异常类型
在 Java 中所有异常类型都是内置类 java.lang.Throwable 类的子类，即 Throwable 位于异常类层次结构的顶层。Throwable 类下有两个异常分支 Exception 和 Error，如图 1 所示。

图1 异常结构图

由图 2 可以知道，Throwable 类是所有异常和错误的超类，下面有 Error 和 Exception 两个子类分别表示错误和异常。其中异常类 Exception 又分为运行时异常和非运行时异常，这两种异常有很大的区别，也称为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。

Exception 类用于用户程序可能出现的异常情况，它也是用来创建自定义异常类型类的类。
Error 定义了在通常环境下不希望被程序捕获的异常。Error 类型的异常用于 Java 运行时由系统显示与运行时系统本身有关的错误。堆栈溢出是这种错误的一例。
本章不讨论关于 Error 类型的异常处理，因为它们通常是灾难性的致命错误，不是程序可以控制的。本章接下来的内容将讨论 Exception 类型的异常处理。

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

非运行时异常是指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如 IOException、ClassNotFoundException 等以及用户自定义的 Exception 异常，一般情况下不自定义检查异常。表 1 列出了一些常见的异常类型及它们的作用。

表1 Java中常见的异常类型
异常类型 说明
Exception 异常层次结构的根类
RuntimeException 运行时异常，多数 java.lang 异常的根类
ArithmeticException 算术谱误异常，如以零做除数
ArraylndexOutOfBoundException 数组大小小于或大于实际的数组大小
NullPointerException 尝试访问 null 对象成员，空指针异常
ClassNotFoundException 不能加载所需的类
NumberF ormatException 数字转化格式异常，比如字符串到 float 型数字的转换无效
IOException I/O 异常的根类
F ileN otF oundException 找不到文件
EOFException 文件结束
InterruptedException 线程中断
IllegalArgumentException 方法接收到非法参数
ClassCastException 类型转换异常
SQLException 操作数据库异常

在java应用程序中，有两种异常处理机制：抛出异常、捕获异常。

声明异常抛出异常：

　　当一个方法出现错误引发异常时，方法创建异常对象交付运行时系统，异常对象中包含了异常类型和异常出现时程序的状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

　　可以通过 throws 关键字在方法上声明该方法要拋出的异常，然后在方法内部通过 throw 拋出异常对象。本节详细介绍在 Java 中如何声明异常和拋出异常。

throws 关键字和 throw 关键字在使用上的几点区别如下：

throws 用来声明一个方法可能抛出的所有异常信息，throw 则是指拋出的一个具体的异常类型。
通常在一个方法（类）的声明处通过 throws 声明方法（类）可能拋出的异常信息，而在方法（类）内部通过 throw 声明一个具体的异常信息。
throws 通常不用显示地捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法； throw 则需要用户自己捕获相关的异常，而后再对其进行相关包装，最后将包装后的异常信息抛出。
throws 声明异常
　　当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。可以使用 throws 关键字在方法的头部声明一个异常，其具体格式如下：

returnType method_name(paramList) throws Exception 1,Exception2,…{…}

其中，returnType 表示返回值类型，method_name 表示方法名，Exception 1，Exception2，… 表示异常类。如果有多个异常类，它们之间用逗号分隔。这些异常类可以是方法中调用了可能拋出异常的方法而产生的异常，也可以是方法体中生成并拋出的异常。

例 1
创建一个 readFile() 方法，该方法用于读取文件内容，在读取的过程中可能会产生 IOException 异常，但是在该方法中不做任何的处理，而将可能发生的异常交给调用者处理。在 main() 方法中使用 try catch 捕获异常，并输出异常信息。代码如下：

复制代码
import java.io.FileInputStream;
import java.io.IOException;
public class Test04
{

public void readFile() throws IOException
{
    //定义方法时声明异常
    FileInputStream file=new FileInputStream("read.txt");    //创達 FileInputStream 实例对象
    int f;
    while((f=file.read())!=-1)
    {
        System.out.println((char)f);
        f=file.read();
    }
    file.close();
}
public static void main(String[] args)
{
    Throws t=new Test04();
    try
    {
        t.readFile();    //调用 readFHe()方法
    }
    catch(IOException e)
    {    //捕获异常
        System.out.println(e);
    }
}

}
复制代码
以上代码，首先在定义 readFile() 方法时用 throws 关键字声明在该方法中可能产生的异常，然后在 main() 方法中调用 readFile() 方法，并使用 catch 语句捕获产生的异常。

注意：在编写类继承代码时要注意，子类在覆盖父类带 throws 子句的方法时，子类的方法声明中的 throws 子句不能出现父类对应方法的 throws 子句中没有的异常类型，因此 throws 子句可以限制子类的行为。也就是说，子类方法拋出的异常不会超过父类定义的范围。

throw 拋出异常
throw 语句用来直接拋出一个异常，后接一个可拋出的异常类对象，其语法格式如下：

throw ExceptionObject;
其中，ExceptionObject 必须是 Throwable 类或其子类的对象。如果是自定义异常类，也必须是 Throwable 的直接或间接子类。例如，以下语句在编译时将会产生语法错误：

throw new String("拋出异常"); //因为String类不是Throwable类的子类

当 throw 语句执行时，它后面的语句将不执行，此时程序转向调用者程序，寻找与之相匹配的 catch 语句，执行相应的异常处理程序。如果没有找到相匹配的 catch 语句，则再转向上一层的调用程序。这样逐层向上，直到最外层的异常处理程序终止程序并打印出调用栈情况。

例 2
在某仓库管理系统中，要求管理员的用户名需要由 8 位以上的字母或者数字组成，不能含有其他的字符。当长度在 8 位以下时拋出异常，并显示异常信息；当字符含有非字母或者数字时，同样拋出异常，显示异常信息。代码如下：

复制代码
import java.util.Scanner;
public class Test05
{

public boolean validateUserName(String username)
{
    boolean con=false;
    if(username.length()>8)
    {    //判断用户名长度是否大于8位
        for(int i=0;i<username.length();i++)
        {
            char ch=username.charAt(i);    //获取每一位字符
            if((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
            {
                con=true;
            }
            else
            {
                con=false;
                throw new IllegalArgumentException("用户名只能由字母和数字组成！"");
            }
        }
    }
    else
    {
        throw new IllegalArgumentException("用户名长度必须大于 8 位！");
    }
    return con;
}
public static void main(String[] args)
{
    Test05 te=new Test05();
    Scanner input=new Scanner(System.in);
    System.out.println("请输入用户名：");
    String username=input.next();
    try
    {
        boolean con=te.validateUserName(username);
        if(con)
        {
            System.out.println("用户名输入正确！");
        }
    }
    catch(IllegalArgumentException e)
    {
        System.out.println(e);
    }
}

}
复制代码

如上述代码，在 validateUserName() 方法中两处拋出了 IllegalArgumentException 异常，即当用户名字符含有非字母或者数字以及长度不够 8 位时。在 main() 方法中，调用了 validateUserName() 方法，并使用 catch 语句捕获该方法可能拋出的异常。

运行程序，当用户输入的用户名包含非字母或者数字的字符时，程序输出异常信息，如下所示。

请输入用户名：
administrator@#
java.lang.IllegalArgumentException: 用户名只能由字母和数字组成！

当用户输入的用户名长度不够 8 位时，程序同样会输出异常信息，如下所示。

请输入用户名：
admin
java.lang.IllegalArgumentException: 用户名长度必须大于 8 位！
捕获异常：

　　在方法抛出异常后，运行时系统将转为寻找合适的异常处理器。潜在的异常处理器是异常发生时依次存存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到合适的异常处理器的方法并执行。当运行时系统遍历调用栈，而未找到合适的异常处理器方法时，运行时系统终止，同时意味着java程序的终止。

通常使用try、catch、finally来捕获异常：

复制代码
try
{

逻辑代码块

}
catch(ExceptionType e)
{

异常处理代码块

}
finally
{

清理代码块

}
复制代码
try块:用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟个finally块。

catch块:用于处理try捕获到的异常。

finally块:无论是否捕获或处理异常,finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally 语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行:

1)在finally语句块中发生了异常。

2)在前面的代码中用了System. exit(退出程序。

3)程序所在的线程死亡。

4)关闭CPU。

try、catch、finally 语句块的执行顺序:

1)当try没有捕获到异常时: try 语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句;

2)当try捕获到异常，catch语句块里没有处理此异常的情况:当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally 语句块里的语句还是会被执行，但finally语句块后的语句不会被执行;

3)当try捕获到异常，catch 语句块里有处理此异常的情况:在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch 语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句。
原文地址https://www.cnblogs.com/l199616j/p/11297326.html