1，Error 和 Exception的联系
Error 和 Exception都继承自Throwable
2，Error 和 Exception的区别
Error：表示由 JVM 所侦测到的无法预期的错误，由于这是属于 JVM 层次的严重错误，导致 JVM 无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，顶多只能显示错误信息。
Exception：表示可恢复的例外/异常，这是可捕捉到的。
Java 提供了两类主要的异常：RuntimeException和checked exception。
checked异常也就是我们经常遇到的 IO 异常，以及SQL 异常等。对于这种异常，JAVA 编译器强制要求我们必需对出现的这些异常进行处理。
但是RuntimeException，也称运行时异常，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException 异常，它就是运行时异常，并且这种异常还是最常见的异常之一。
出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由 Thread.run() 抛出 ，如果是单线程就被 main() 抛出 。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。运行时异常是 Exception 的子类，也有一般异常的特点，也是可以被 Catch 块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。
如果不想终止，则必须捕捉所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。在这个场景这样处理可能是一个比较好的应用，但并不代表在所有的场景都应该如此。如果在其它场景，遇到了一些错误，如果退出程序比较好，这时你就可以不理会运行时异常 。
异常处理的目标之一就是为了把程序从异常中恢复出来 。
对于Checked异常的处理方式有两种：
（1）当前方法明确知道如何处理该异常，程序应该使用try…catch块来捕获该异常，然后在对应的catch块中修补该异常。
（2）当前方法不知道如何处理这种异常，应该在定义该方法时声明抛出该异常。
3，抛出异常
抛出异常有三种形式，一个是throw，一个throws，还有一种系统自动抛异常。
3.1系统自动抛异常
当程序语句出现一些逻辑错误、主义错误或类型转换错误时，系统会自动抛出异常。如：
[java] view plain copy
1. public static void main(String[] args) {
2. int a = 5, b =0;
3. 5/b);
4. //function();
5. }
系统会自动抛出
ArithmeticException
异常：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at test.ExceptionTest.main(ExceptionTest.java:62)
再如
[java] view plain copy
1. public static void main(String[] args) {
2. "abc";
3. System.out.println(Double.parseDouble(s));
4. //function();
5. }
系统会自动抛出
NumberFormatException
异常：
Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1224)
at java.lang.Double.parseDouble(Double.java:510)
at test.ExceptionTest.main(ExceptionTest.java:62)
3.2 throw语句抛出一个异常
语法：throw (异常对象);
如： throw e;
一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。如：
[java] view plain copy
1. public static void main(String[] args) {
2. "abc";
3. if(s.equals("abc")) {
4. throw new NumberFormatException();
5. else {
6. System.out.println(s);
7. }
8. //function();
9. }
会抛出异常：
Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)
3.3 throws
throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
如： public void function() throws Exception{......}
当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。如：
[java] view plain copy
1. public static void function() throws NumberFormatException{
2. "abc";
3. System.out.println(Double.parseDouble(s));
4. }
5.
6. public static void main(String[] args) {
7. try {
8. function();
9. catch (NumberFormatException e) {
10. "非数据类型不能转换。");
11. //e.printStackTrace();
12. }
13. }
处理结果如下：
非数据类型不能转换。
3.4 throw 与 throws的比较
1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
好的编程习惯：
1.在写程序时，对可能会出现异常的部分通常要用try{...}catch{...}去捕捉它并对它进行处理；
2.用try{...}catch{...}捕捉了异常之后一定要对在catch{...}中对其进行处理，那怕是最简单的一句输出语句，或栈输入e.printStackTrace();
3.如果是捕捉IO输入输出流中的异常，一定要在try{...}catch{...}后加finally{...}把输入输出流关闭；
4.如果在函数体内用throw抛出了某种异常，最好要在函数名中加throws抛异常声明，然后交给调用它的上层函数进行处理。
4，捕获异常
先讲捕捉异常
[java] view plain copy
1. try{
2. ……
3. }catch(Exception e){
4. ……
5. }finally{
6. ……
7. }
try{……}中放置可能会发生异常的的语句块，如可能出现异常的函数，也可以是一般的程序语句；catch(){……}用于抓住异常，(Exception e)中Exception是异常的类型，必须是Exception(Exception是所有异常类的父类)的子类。{}定义当出现异常时的处理方法。finally{……}表示不管异常是否发生，都得进行finally{}中的处理。finally中的代码会在try中return语句执行之前执行，如果finally中也有return语句并且可以正常执行，则try中的return语句不会被执行。
在捕捉异常的try{...}语句块中，如果出现了异常，则该语句(出现异常的语句)后的程序语句都不执行，而是跳到catch{...}语句块中执行异常的处理。如：
[java] view plain copy
1. public static void function1() throws NumberFormatException{
2. "abc"));
3. "第二条语句。");
4.
5. }
6.
7. public static void main(String[] args) {
8. try {
9. function1();
10. catch (Exception e) {
11. System.err.println(e.getMessage());
12. //e.printStackTrace();
13. }
14. }
结果如下，只输出了一条错误提示语：
For input string: "abc"
System.out.println("第二条语句。");未执行。
如果一个函数没有用throws进行抛异常，在调用该函数的方法也同样可以捕捉异常。如
[java] view plain copy
1. public static void function() {
2. "abc";
3. System.out.println(Double.parseDouble(s));
4. }
5.
6. public static void main(String[] args) {
7. try {
8. function();
9. catch (Exception e) {
10. "非数据类型不能转换。");
11. //e.printStackTrace();
12. }
13. }
处理结果如下：
非数据类型不能转换。
说明：某个函数或某段程序块不管会不会，有没可能抛出异常，都可以加try{...}catch{...}去捕捉它。
5，自定义异常
用户可以自定义异常，新建一个异常类，让其继承Exception类或Exception的某个子类。然后用throw抛出自己定义的异常类对象。如：
[java] view plain copy
1. public static void function() throws ParenthesisMatchingException{
2. "((a+b)";
3. new ParenthesisMatchingException("括号匹配异常！");
4. if(s.charAt(0)=='(' && s.charAt(1)=='(') {
5. throw e;
6. }
7. System.out.println(s);
8. }
9.
10. public static void main(String[] args) {
11. try {
12. function();
13. catch (Exception e) {
14. System.out.println(e.getMessage());
15. //e.printStackTrace();
16. }
17. }
结果如下 ：
括号匹配异常！
