初识异常（Exception）

• 比如我们在取数组里面的某个值得时候，经常会出现定义的取值范围超过了数组的大小，那么运行的时候JVM就会发出异常提示。

  
  
  BoundException.png

• 再比如我们要处理的数据超出了系统数据类型表示范围时，由操作系统发出的Error提示。

  
  
  MemoryError.png

发生异常的原因有很多，但是通常有以下几大类：输入了违法的数据、找不到要打开的文件、网络通信中断、JVM内存溢出。

Java异常类层次

Java是通过Throwable类的所有子类来描述各种异常。所有异常的老祖宗都是Throwable。

Throwable.png

可查异常、不可查异常

• 可查异常（编译器要求必须处置的异常）：指程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。
  除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

• 不可查异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。
  运行时异常RuntimeException 是可能被程序员避免的异常。它是Exception的一个重要子类，是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。例如：ArithmeticException，一个整数“除以零”时会抛出此异常；ArrayStoreException，试图将错误类型的对象存储到一个对象数组时抛出此异常；IndexOutOfBoundsException，表示某排序索引（例如对数组、字符串排序）超出范围时抛出此异常；NullPointerException，当应用程序试图在需要对象的地方使用 null 时抛出该异常。这些异常都是不检查异常，程序中可以选择捕获处理，也可以不处理。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

异常方法

下面的列表是 Throwable 类的主要方法:

Method.png

异常处理机制

在 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