本文将向读者介绍如何编写正确的异常处理程序，并将展示当方法出问题的时候，如何产生自定义异常。如有不对欢迎拍砖，谢谢。

文章出处

文章出自：安卓进阶学习指南
主要贡献者：
justdoitJX
YangZhe
Milo

问题

• 什么是异常，异常的分类有哪些？
• RuntimeException和CheckedException的区别、error和exception的区别?
• 常见RuntimeException(运行时异常)和CheckedException(检查型异常)有哪些？
• 异常的机制(异常处理的流程)？
• 异常的使用方法(如何抛出异常，如何捕获异常，再次抛出异常)?
• throws,throw,try,catch,finally分别代表什么意义？
• 什么是“异常链”?
• 怎么自定义异常？
• Java异常类有哪些的重要方法？

什么是异常

异常是发生在程序执行过程中阻碍程序正常执行的错误事件；比如打开的文件不存在、网络连接中断、操作数组越界等都会导致出现异常。

异常的分类

Throwable.png

异常的基类为Throwable，Error和Exception继承Throwable。

Error(错误):是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。

Exception:这种异常分两大类RuntimeException(运行时异常)和CheckedException(编译时异常);

常见的RuntimeException有：

ArrayIndexOutOfBoundsException(数组索引越界异常)
NullPointerException(空指针异常)
ClassNotFoundException(找不到类异常)
IllegalArgumentException(非法参数异常)
SecurityException(安全性异常)

常见的CheckedException有：

NoSuchMethodException(方法未找到抛出的异常)
ClassCastException(类型转换异常类)
NumberFormatException(字符串转换为数字抛出的异常)
IOException(操作输入流和输出流时可能出现的异常)

Java 异常关键字：try、catch 、finally 、throw 、throws

public Test() {
        try {
            int i = 10 / 0;
            System.out.println("i=" + i);
        } catch (ArithmeticException e) {
            //捕获 ArithmeticException
        } catch (Exception e) {
            //捕获 Exception
            throw e;
        } finally {
            //do something
        }
    }

    public void test1() throws Exception {
        //do something
    }

1）异常处理机制

我们都知道除数不能为0，否则程序就会报错。像Java中其他对象的创建一样，使用new在堆上创建异常对象。然后终止当前的执行路径，并且从当前环境中弹出异常对象的引用。此时，异常机制接管程序，并开始寻找一个恰当的地方继续执行程序。这个恰当的地方就是异常处理程序，它的任务是将程序从错误状态中恢复，以使程序能要么换一种方式运行，要么继续下去。

2）抛出异常的方式

• 使用throw抛出异常：throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。例如抛出一个IOException类的异常对象：
  throw new IOException ;

• throws抛出异常：如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为：methodname throws Exception1,Exception2,..,ExceptionN {} 。
  当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法去处理。

3）重新抛出异常

有时希望把刚捕获的异常重新抛出，尤其是在使用Exception捕获所有异常的时候。既然已经得到了对当前异常的引用，可以直接把它重新抛出：

catch(Exception e){
    System.out,println("An exception was thrown");
    throw e;
}

重抛异常会把异常抛给上一级环境中的异常处理程序，同一个try块的后续catch子句将被忽略。

注意：

1. 如果是Error、RuntimeException或它们的子类，那么不可使用throws关键字来声明要抛出的异常，虽然编译可以通过，但是在运行时会被系统抛出。

2. 如果一个方法出现编译时异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误。

3. 仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。

4. 调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

4）捕获异常

在Java中，异常通过try-catch语句捕获。其一般语法形式为：

try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1){  
    // 捕获并处置try抛出的异常类型Type1  
}  
catch (Type2 id2){  
     //捕获并处置try抛出的异常类型Type2  
}  

异常处理程序必须紧跟在try块之后。当异常被抛出时，异常处理机制将负责搜寻参数与异常类型想匹配的第一个处理程序。然后进入catch子句执行，此时认为异常的得到了处理。一旦catch子句结束，则处理程序的查找过程结束。只有匹配的catch子句才能得到执行。

可以写一个异常处理程序来捕获所有类型的异常。

catch(Exception e){
    System.out.println("Caught an exception");
}

这将捕获所有异常，所以最好把它放在程序列表的末尾，以防它抢在其他处理程序之前先把异常捕获了。

因为Exception是与编程有关的所有异常类的基类，所以他不会含有太多具体的信息，不过可以调用它从其基类Throwable继承的方法：

String getMessage()

String getLocalizedMessage()

用来获取详细信息，或用本地语言表示的详细信息。

String toString()

返回对Throwable的简单描述，要是有详细信息的话，也会把它包含在内。

void printStackTrace()

void printStackTrace(PrintStream)

void printStackTrace(java.io.PrintWriter)

打印Throwable和Throwable的调用栈轨迹。其中第一个版本输出到标准错误，后两个版本允许选择输出的流。
Throwable fillInStackTrace()
用于在Throwable对象的内部记录栈帧的当前状态。这在程序重新抛出错误或异常时很有用。
此外，也可以使用Throwable从其基类Object继承的方法。

5）异常链

常常会想要在捕获一个异常后抛出另一个异常，并且希望把原始异常的信息保存下来，这被称为异常链。现在所有Throwable的子类在构造器中都可以接受一个cause(因由)对象作为参数。这个cause就用来表示原始异常，这样通过把原始异常传递给新的异常，使得即使当前位置创建并抛出了新的异常，也能通过这个异常链追踪到异常最初发生的位置。

6）finally

无论是否捕获或处理异常，finally块里的语句都会被执行，甚至在异常没有被当前的异常处理程序捕获的情况下，异常处理机制也会跳到更高一层的异常处理程序之前，执行finally子句，当涉及break及continue语句的时候，finally子句也会得到执行。当要把除内存之外的资源恢复到它们的初始状态时，就要用到finally子句，如已经打开的文件或网络连接，在屏幕上画的图形，甚至可以是外部世界的某个开关。
当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：

• 在finally语句块中发生了异常。
• 在前面的代码中用了System.exit()退出程序。
• 程序所在的线程死亡。
• 关闭CPU。

如何自定义异常

public class MyException extends Exception{
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }

    public MyException(String message, Throwable cause) {
        super(message, cause);
    }

    public MyException(Throwable cause) {
        super(cause);
    }

}

    public void test2() throws MyException {
        //do something
        throw new MyException("");
    }

    public void test3() {
        //do something
        try {
            throw new MyException("");
        } catch (MyException e) {
            e.printStackTrace();
        }
    }

自定义异常通常是定义一个继承自Exception类的子类。一般情况下我们都会直接继承自Exception类，而不会继承某个运行时的异常类。在程序中使用自定义异常类，大体可分为以下几个步骤。

1. 创建自定义异常：

2. 在方法中通过throw关键字抛出异常对象：

3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

4. 在出现异常方法的调用者中捕获并处理异常。

总结

Java异常是Java提供的一种识别及响应错误的一致性机制。
Java异常机制可以使程序中异常处理代码和正常业务代码分离，降低耦合度。保证程序代码更加优雅，并提高程序健壮性。在有效使用异常的情况下，异常能清晰的回答what, where, why这3个问题：异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪“抛出，异常信息回答了“为什么“会抛出。

Thanks

《Java 编程思想》
http://blog.csdn.net/you_off3/article/details/7572471
https://www.cnblogs.com/skywang12345/p/3544168.html#a2
http://www.importnew.com/1701.html