初识异常（Exception）
-
比如我们在取数组里面的某个值得时候，经常会出现定义的取值范围超过了数组的大小，那么运行的时候JVM就会发出异常提示。
BoundException.png -
再比如我们要处理的数据超出了系统数据类型表示范围时，由操作系统发出的Error提示。
MemoryError.png
发生异常的原因有很多，但是通常有以下几大类：输入了违法的数据、找不到要打开的文件、网络通信中断、JVM内存溢出。
Java异常类层次
Java是通过Throwable类的所有子类来描述各种异常。所有异常的老祖宗都是Throwable。
Throwable
Throwable 类是所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 中的参数类型。Throwable类有两个重要的子类：Exception（异常）和 Error（错误）。
Error
Java程序通常不捕获错误，出现错误一般都出现了比较严重的故障，此时程序已经无法处理了，然后在控制台通知你，我已经歇菜了。大多数错误与程序的执行操作无关，而是程序运行时，JVM出了问题，如系统崩溃，虚拟机错误，内存空间不足等。这些错误，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception
Exception类表示程序可以处理的异常，是可以捕获且可能恢复的。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。通常，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。
可查异常、不可查异常
可查异常（编译器要求必须处置的异常）：指程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。
除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。不可查异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。
运行时异常RuntimeException 是可能被程序员避免的异常。它是Exception的一个重要子类，是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。例如：ArithmeticException，一个整数“除以零”时会抛出此异常；ArrayStoreException，试图将错误类型的对象存储到一个对象数组时抛出此异常；IndexOutOfBoundsException，表示某排序索引（例如对数组、字符串排序）超出范围时抛出此异常；NullPointerException，当应用程序试图在需要对象的地方使用 null 时抛出该异常。这些异常都是不检查异常，程序中可以选择捕获处理，也可以不处理。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
异常方法
下面的列表是 Throwable 类的主要方法:
异常处理机制
在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。异常总是先被抛出，后被捕捉的。
- 抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
注意：
对于运行时异常、错误或可查异常，Java技术所要求的异常处理方式有所不同。
① 由于运行时异常的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。
② 对于所有的可查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。
代码示例
① throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。
② 当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。
③ throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到。
public class ClassName
{
public void named(String string) throws RemoteException
{
// Method implementation
throw new RemoteException();
}
//Remainder of class definition
}
一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
public class ClassName
{
public void withdraw(double amount) throws RemoteException, InsufficientFundsException
{
// Method implementation
}
//Remainder of class definition
}
- 捕获异常：使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
语法
try
{
// 程序代码
}catch(ExceptionName e)
{
//Catch 块
}
当try内的监控区域发生异常，就会匹配后面的catch块。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。
匹配的原则是：如果抛出的异常对象属于catch块的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。
try/catch 实例：
public class Test{
public static void main(String args[]){
try{
int a[] = new int[2];
System.out.println("输出数组 :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("抛出异常 :" + e);
}
}
}
多重捕获块：
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}
如果监控区域发生异常，异常被抛给第一个 catch 块。如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。如果不匹配，它会被传递给第二个 catch 块。如此，直到异常被捕获或者通过所有的 catch 块。
多重捕获块实例：
public class TestException {
public static void main(String[] args) {
int[] intArray = new int[3];
try {
for (int i = 0; i <= intArray.length; i++) {
intArray[i] = i;
System.out.println("intArray[" + i + "] = " + intArray[i]);
System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值: "
+ intArray[i] % (i - 2));
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("intArray数组下标越界异常。");
} catch (ArithmeticException e) {
System.out.println("除数为0异常。");
}
System.out.println("程序正常结束。");
}
}
//intArray[0] = 0
//intArray[0]模 -2的值: 0
//intArray[1] = 1
//intArray[1]模 -1的值: 0
//intArray[2] = 2
//除数为0异常。
//程序正常结束。
注意：一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
finally关键字
① 无论是否发生异常，finally 代码块中的代码总会被执行。
② 在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
③ finally 代码块出现在 catch 代码块最后。
④ finally中使用return是一种很不好的编程风格，它会覆盖掉所有的其它返回，并且吃掉catch中抛出的异常。
语法如下：
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
代码实例：
public class ExcepTest{
public static void main(String args[]){
int a[] = new int[2];
try{
System.out.println("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
finally{
a[0] = 6;
System.out.println("First element value: " +a[0]);
System.out.println("The finally statement is executed");
}
}
}
//Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
//First element value: 6
//The finally statement is executed
注意：当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在finally语句块中发生了异常，finally块不会被执行。
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语句块后的语句；
自定义异常
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int a =3;
int b =0;
try { // try语句包含可能发生异常的语句
int result = quotient(a, b); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
注意
子类重写父类的方法的时候，如果父类没有异常，那么子类也不允许在重写的方法抛出异常有异常。也就是说父类没有抛出异常，那么子类也不可以。
写完喽！ㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏ
知识重在总结和梳理，只有不断地去学习并运用，才能化为自己的东西。当你能为别人讲明白的时候，说明自己已经掌握了。
欢迎转载，转载请注明出处！
如果有错误的地方，或者有您的见解，还请不啬赐教！
喜欢的话，麻烦点个赞！
本文转载自：http://blog.csdn.net/hguisu/article/details/6155636
l