JAVA异常处理

异常的概念

异常就是在程序运行过程中由于硬件设备的问题、软件设计错误、缺陷等导致的程序错误。在软件开发的过程中，很多情况都将导致异常的产生，例如文件不存在、网络异常等。

在java中，异常用对象表示。在一个方法的运行过程中，如果发生了异常，则这个方法（或者java虚拟机）生成一个代表该异常的对象，该异常对象中包括了异常事件类型以及发生异常时应用程序目前的状态和调用过程。

异常的分类

java类库中定了了丰富的异常类表示各种各样的异常，所有这些异常都是由Throwable继承而来的。Throwable类有两个子类：Error和Exception。如果类库中的异常类不能满足要求，还可以自己定义异常类。



Error类的子类描述了java虚拟机的内部错误和资源耗尽错误。例如：动态链接库失败、线程死锁等。Error类的对象由java虚拟机生成并抛出，程序中通常不对这类错误进行处理。

Exception类是所有异常类的父类。其子类对应了各种各样可能出现的异常。该类定义分为运行时异常（RuntimeException）与非运行时异常。

RuntimeException是一类特殊的异常，java虚拟机在运行过程中出现的异常，这类异常在正常情况下编译时通常发现不了，只有在运行时才会发现，比如数组下标越界等。此类异常不处理也可以正常编译。

非运行时异常是一般程序中可以预知的问题，其产生的异常可能带来意想不到的结果。如果不处理则编译不通过。

异常的处理

捕获异常

在java中，对容易发生异常的代码，可以通过

try-catch

语句进行捕获处理。在

try

语句快中编写可能发生异常的代码，然后在catch语句块中捕获执行这些代码时可能发生的异常。格式如下：

try {
//可能产生异常的代码
} catch (异常类 异常对象) {
//异常处理代码
}

try语句是一个语句块，抛出异常的代码放在try后面的{}内。catch中的异常类必须与try抛出的异常对象匹配。才能捕获异常。这种匹配包括两种方式：

catch中的异常类型就是try抛出的异常对象对应的异常类

catch中的异常类型是抛出的异常对象的超类

如果catch中的异常类与抛出的一场对象不匹配，则不能捕获异常，最终被虚拟机捕获。

我们来写一个捕获异常的例子：

import java.text.ParseException;

public class ExceptionDemo
{
public static void main(String[] args) throws ParseException
{
char[] chars = "jiang".toCharArray();
int len = chars.length;
try
{
// 循环输出数组内容，并使下标越界
for (int i = 0; i <= len; i++)
{
// 此句可能会抛出IndexOutOfBoundsException
System.out.println(chars[i]);
}
System.out.println("success");
}
// 捕获并处理异常
catch (IndexOutOfBoundsException e)
{
System.out.println("数组下标越界：" + e.getMessage());
}
}
}

运行结果：

j

i

a

n

g

数组下标越界：5

通过上面的例子，我们知道了如何简单的处理异常，使程序可以正常的运行下去。我们仔细思考一下会发现：

如果try块中的所有语句都正常执行完毕，则catch块中的所有语句都将被忽略

如果try块在执行过程中遇到异常，并且这个异常与catch中声明的异常类型匹配，那么try块中剩余代码将被忽略

如果try语句块在执行中碰到了异常，而抛出的异常与catch中声明的异常类型不匹配，那么方法立即退出

在程序设计过程中，我们可能会遇到代码块可能会抛出多种类型的异常，那么针对于这种情况我们应该使用多个catch快进行捕获处理。但是要注意的是，如果异常存在继承关系，那么子类应该放在上面。

import java.text.ParseException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class ExceptionDemo
{
public static void main(String[] args) throws ParseException
{
Scanner scanner = new Scanner(System.in);
int c = 0;
try
{
System.out.print("请输入a的值：");
int a = scanner.nextInt();
System.out.print("请输入b的值：");
int b = scanner.nextInt();
c = a / b;
System.out.print("a/b=");
System.out.println(c);
}
catch (InputMismatchException e1)
{
System.out.println("请输入一个整数");
}
catch (ArithmeticException e2)
{
System.out.println("被除数不能为0");
}
catch (Exception e)
{
System.out.println("捕获异常");
}
}
}

输入的数据不同，运行的结果也不同，这里就不展示运行结果了。

除了以上两种情况，有时候我们希望，无论代码有没有发生异常，都需要执行某些代码，比如关闭连接、释放资源等。这个时候，我们需要在

try-catch

块后加入

finally

语句块，可以确保无论是否发生异常，

finally

语句块总是会被执行。语法格式如下：

try {
//可能产生异常的代码
} catch (异常类 异常对象) {
//异常处理代码
}
finally {
//总是要执行的代码块
}

修改上面的例子，使用finally，我么可以这样写：

import java.text.ParseException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class ExceptionDemo
{
public static void main(String[] args) throws ParseException
{
Scanner scanner = new Scanner(System.in);
int c = 0;
try
{
System.out.print("请输入a的值：");
int a = scanner.nextInt();
System.out.print("请输入b的值：");
int b = scanner.nextInt();
c = a / b;
System.out.print("a/b=");
System.out.println(c);
}
catch (InputMismatchException e1)
{
System.out.println("请输入一个整数");
}
catch (ArithmeticException e2)
{
System.out.println("被除数不能为0");
}
catch (Exception e)
{
System.out.println("捕获异常");
}
finally
{
System.out.println("进入finally");
}
}
}

抛出异常

在编程过程中，有些问题在当前环境下是无法解决的，此时需要将问题交给调用者去解决，这个时候就需要抛出异常。格式为：

throw 异常对象

其中，异常对象必须是继承自Throwable的异常类对象，异常抛出点后的代码将不在执行。

public class Student
{
private String no;

public String getNo()
{
return no;
}

public void setNo(String no)
{
if (no == null)
{
throw new IllegalArgumentException("no不能为空");
}
this.no = no;
System.out.println(no);
}

}

声明异常

如果在一个方法中生成了异常，但是该方法并不确定该如何处理该异常，在这种情况下，可以不处理该异常，而是沿着调用层次向上传递，交由调用者处理这些异常。通过声明异常，方法调用者会知道方法可能产生怎样的异常并作出相应处理。

java语句通过

throws

关键字声明异常。所以上面的例子我们可以这样写：

public class Student
{
private String no;

public String getNo()
{
return no;
}

public void setNo(String no) throws IllegalArgumentException
{
if (no == null)
{
throw new IllegalArgumentException("no不能为空");
}
this.no = no;
System.out.println(no);
}

}

自定义异常

java内置的异常对象可以帮助我们处理大部分的异常情况，如果内置异常不足以满足我们的需求时，我们可以自定义异常。

自定义的异常类必须继承自Throwable类，才能被视为异常类，通常是继承自Exception类或Exception类的子孙类。