一、异常的概念
异常指的是运行期出现的错误，也就是当程序开始执行以后执行期出现的错误。出现错误时观察错误的名字和行号最为重要。
异常发生的原因：
用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。
二、异常的分类
检查性异常（Exception）：用户错误或问题引起的异常，这是程序员无法预见的。是异常的父类，子类需要用户显式声明或捕获；例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常（Runtime Exception）： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。例如，除数为0，数组下标超出范围等。
错误（ERROR）：由Java虚拟机生成并抛出，错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，栈溢出，一个错误就发生了，它们在编译也检查不到的；动态链接失败；虚拟机错误。
Exception的层次
所有的异常类是从java.lang.Exception类继承的子类，Exception类是Throwable类的子类。除了Exception类外，Throwable还有一个子类Error 。Java程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。
Throwable类：可以被抛出的，是所有异常类的根基类，所有的异常类都是从它继承。
Error类：是不能处理的错误。Java虚拟机（JVM）运行时出错，用来指示运行时环境发生的错误。例如，JVM内存溢出。一般地，程序不会从错误中恢复。
IOException......类：这些错误必须被处理；
Runtime Exception类：不一定都要处理，可以忽略；
三、异常的捕获和处理
Java异常处理的五个关键字：try、catch、finally、throw、throws 。
捕获异常
使用try和catch关键字可以捕获异常。try/catch/finally代码块放在异常可能发生的地方。
try/catch代码块中的代码称为保护代码，使用 try/catch/finally的语法如下：
try
{
// 可能抛出异常的语句
}catch(ExceptionName e1)
{
//Catch 块
}catch(ExceptionName e1)
{
//Catch 块
}finally{
...
}
try语句：捕获可能抛出异常的语句，如果有例外异常，交给后面的catch语句进行相应处理，后面可以跟一个或多个catch代码段。
Catch语句：包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try后面的catch块就会被检查。
如果发生的异常包含在catch块中，异常会被传递到该catch块处理。在catch代码块中可以用一些方法获取异常信息
getMessage()方法：用来得到有关异常事件的信息。
printStackTrace()方法：一般使用这种方法，包括了getMessage()方法，用来跟踪异常事件发生时执行堆栈的内容。使用前需要 new 一个错误对象再调用，因为它是专属某个错误对象里面的方法，
finally语句：为异常处理提供的统一出口，无论是否发生异常都执行，可以不写。在finally语句中，可以进行资源的清除工作，例如，打开关闭文件、删除临时文件...
实例
下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第三个元素的时候就会抛出一个异常。
import java.io.*;
public class ExcepTest{
public static void main(String args[]){
try{
int a[] = new int[2];
System.out.println("Access element three :" + a[3]); //可能抛出异常语句
}catch(Exception e1){ //捕获数组下标越界异常
System.out.println("数组下标越界");
}catch(ArrayIndexOutOfBoundsException e2){
System.out.println("异常发生"); //输出错误信息
}
}
}
因为Exception类中包含ArrayIndexOutOfBoundsException异常，所以第二个catch异常重复，是不允许的，编译不会通过。
以上代码编译运行输出结果如下：
Exception thrown :java.lang.ArrayIndexOutOfBoundsException:
throws/throw关键字：
如果一个方法没有捕获一个检查性异常，那么该方法必须使用throws 关键字来声明。throws关键字放在方法签名的尾部。
也可以使用throw关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
下面方法的声明抛出一个RemoteException异常：
import java.io.*;
public class className
{
public void deposit(double amount) throws RemoteException
{
// Method implementation
throw new RemoteException();
}
//Remainder of class definition
}
一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
例如，下面的方法声明抛出RemoteException和InsufficientFundsException：
import java.io.*;
public class className
{
public void withdraw(double amount) throws RemoteException,
InsufficientFundsException
{
// Method implementation
}
//Remainder of class definition
}
测试异常
package test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class testException {
/**
* 任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，
* 因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。
* 使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，
* 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
* @throws Exception
*/
void fn() throws Exception{
}
/**
* 已知异常的类型，方法声明时使用throws把异常往外抛
* @param i
* @throws ArithmeticException
*/
void m1(int i) throws ArithmeticException{
}
/**
* 手动抛出异常
* new了一个异常对象，在构建这个对象的时候还可以指定他相关的信息，如这里指明了异常信息“i不能等于0”
* 这个对象抛出去的时候使用getMessage()方法拿到的就是“i不能等于0”这种信息。
* @param i
*/
void m2(int i) {
if (i==0) {
throw new ArithmeticException("i不能等于0");
}
}
/**
* 正常情况下如果这里不写try……catch语句那么程序编译时一定会报错，
* 因为这里有可能会产生两个个必须要处理的异常：FileNotFoundException和IOException。
* 但由于在声明方法f()时已经使用throws把可能产生的这两个异常抛出了，
* 所以这里可以不写try……catch语句去处理可能会产生的异常。
* f()方法把抛出的异常交给下一个要调用它的方法去处理
* @throws FileNotFoundException
* @throws IOException
*/
void f()throws FileNotFoundException,IOException {
//这里有可能会产生FileNotFoundException异常
FileInputStream fis=new FileInputStream("1.txt");
//这里有可能会产生IOException异常
int b = fis.read();
while (b!=-1) {
System.out.println((char)b);
b=fis.read();
}
}
/**
* 在f2()方法里面调用f()方法时必须要处理f()方法抛出来的异常，
* 当然，如果f2()方法也没有办法处理f()方法抛出来的异常，那么f2()方法也可以使用throws把异常抛出，
* 交给下一个调用了f2()的方法去处理f()方法抛出来的异常。
* 这里f2()调用f()方法时，选择不处理f()方法中可能抛出的异常，将异常继续抛出
* @throws Exception
*/
void f2() throws Exception {
f();
}
/**
* f3方法调用f方法捕获f()方法抛出的2个异常并进行处理
*/
void f3() {
try {
f();
} catch (FileNotFoundException e) {
System.out.println(e.getMessage()); //处理的方法是把错误信息打印出来
} catch (IOException e) {
e.printStackTrace(); //处理的方法是使用printStackTrace()方法把错误的堆栈信息全部打印出来。
}
}
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("MyFile.txt");
int b = fis.read(); //这个有可能会抛出IOException异常
while (b != -1) {
System.out.println((char)b);
b = fis.read();
}
} catch (FileNotFoundException e) {
//使用catch捕获FileNotFoundException类异常的异常对象e。并让异常对象e自己调用printStackTrace方法打印出全部的错误信息
e.printStackTrace();
} catch (IOException e) {
//再次使用catch捕获IOException类的异常对象e，并让异常对象e自己调用getMessage()方法将错误信息打印出来。
System.out.println(e.getMessage());;
}finally{
try {
/**
* 前面已经把一个文件打开了，不管打开这个文件时有没有错误发生，即有没有产生异常，最后都一定要把这个文件关闭掉，
* 因此使用了finally语句，在finally语句里面不管前面这个文件打开时是否产生异常，在finally这里执行in.close()都能把这个文件关闭掉，
* 关闭文件也有可能会产生异常，因此在finally里面也使用了try……catch语句去捕获有可能产生的异常。
*/
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
以上代码编译运行输出结果如下：
java.io.FileNotFoundException: MyFile.txt (系统找不到指定的文件。) at java.io.FileInputStream.open0(Native Method) at java.io.FileInputStream.open(FileInputStream.java:195) at java.io.FileInputStream.<init>(FileInputStream.java:138) at java.io.FileInputStream.<init>(FileInputStream.java:93) at test.testException.main(testException.java:88) Exception in thread "main" java.lang.NullPointerException at test.testException.main(testException.java:107)
四、自定义异常
编写自己的异常类时需要记住下面的几点。
继承java.lang.Exception;声明自己的异常类。
如果希望写一个检查性异常类，则需要继承Exception类。
如果你想写一个运行时异常类，那么需要继承RuntimeException 类。
实例：自定义异常
package test;
public class MyException extends Exception{
private int id;
/**
* 自定义异常类的构造方法
* @param message
* @param id
*/
public MyException(String message,int id) {
super(message); //调用父类Exception的构造方法
this.id = id;
}
/**
* 获取异常的代码
* @return
*/
public int getId() {
return id;
}
}
实例：自定义异常测试
package test;
import java.text.MessageFormat;
public class TestMyException {
//throws MyException,抛出我们自定义的MyException类的异常。
public void regist(int num) throws MyException {
if (num < 0) {
//使用throw手动抛出一个MyException类的异常对象。
throw new MyException("人数为负值，不合理", 1);
}
/**
* 注意：当我们抛出了异常之后，
* System.out.println(MessageFormat.format("登记人数：{0}",num));是不会被执行的。
* 抛出异常之后整个方法的调用就结束了。
*/
System.out.println(MessageFormat.format("登记人数：{0}",num));
}
public void manage() {
try {
regist(-100);
} catch (MyException e) {
System.out.println("登记失败，错误码："+e.getId());
e.printStackTrace();
}
System.out.println("操作结束");
}
public static void main(String[] args) {
TestMyException t = new TestMyException();
t.manage();
}
}
登记失败，错误码：1 操作结束 test.MyException: 人数为负值，不合理 at test.TestMyException.regist(TestMyException.java:9) at test.TestMyException.manage(TestMyException.java:21) at test.TestMyException.main(TestMyException.java:32)
登记失败，错误码：1 操作结束 test.MyException: 人数为负值，不合理 at test.TestMyException.regist(TestMyException.java:9) at test.TestMyException.manage(TestMyException.java:21) at test.TestMyException.main(TestMyException.java:32)
文章参考：孤傲苍狼