Throwable、Error、Exception、RuntimeException 区别 联系

1.Throwable 类是 Java 语言中全部错误或异常的超类。它的两个子类是Error和Exception；


2.Error 是 Throwable 的子类，用于指示合理的应用程序不该该试图捕获的严重问题。大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，由于大多数应用程序都不该该试图捕获它。在执行该方法期间，无需在其 throws 子句中声明可能抛出可是未能捕获的 Error 的任何子类，由于这些错误多是不再会发生的异常条件。


3.Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。


4.RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。可能在执行方法期间抛出但未被捕获的RuntimeException 的任何子类都无需在 throws 子句中进行声明。它是Exception的子类。

5.方法重写时：在子类中一个重写的方法可能只抛出父类中声明过的异常或者异常的子类

Error与Exception有什么区别？

Error类和Exception类都继承自Throwable类。

• Error的继承关系：

java.lang.Object 
 java.lang.Throwable
      java.lang.Error

 

• Exception的继承关系：

java.lang.Object
java.lang.Throwable
     java.lang.Exception

 

 

两者的不一样之处：

 

Exception：

1．能够是可被控制(checked) 或不可控制的(unchecked) 

2．表示一个由程序员致使的错误 

3．应该在应用程序级被处理

 

Error：

1．老是不可控制的(unchecked) 

2．常常用来用于表示系统错误或低层资源的错误 

3．如何可能的话，应该在系统级被捕捉

 

 

 

Java 中定义了两类异常： 

　　1) Checked exception: 这类异常都是Exception的子类 。异常的向上抛出机制进行处理，假如子类可能产生A异常，那么在父类中也必须throws A异常。可能致使的问题：代码效率低，耦合度太高。
　　
　　2) Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException一样也是Exception的子类，可是它们是非凡的，它们不能经过client code来试图解决，因此称为Unchecked exception 。

 

 

Java 中异常类的继承关系图：

 

Checked Exception与Runtime Exception 的区别

Java里有个很重要的特点是Exception ，也就是说容许程序产生例外情况。而在学Java 的时候，咱们也只知道Exception 的写法，却未必真能了解不一样种类的Exception 的区别。

　　首先，您应该知道的是Java 提供了两种Exception 的模式，一种是执行的时候所产生的Exception (Runtime Exception)，另一种则是受控制的Exception (Checked Exception)。

　　全部的Checked Exception 均从java.lang.Exception 继承而来，而Runtime Exception 则继承java.lang.RuntimeException 或java.lang.Error (实际上java.lang.RuntimeException 的上一层也是java.lang.Exception)。

　　当咱们撰写程序的时候，咱们极可能会对选择某种形式的Exception 感到困扰，到底我应该选择Runtime Exception 仍是Checked Exception ？

　　其实，在运做上，咱们能够经过Class 的Method 如何产生某个Exception以及某个程序如何处理这个被产生来的Exception 来了解它们之间的差别。
首先咱们先创建一个Exception

[java]  view plain copy

1. public class CException extends Exception {  
2.     public CException() {  
3.     }  
4.   
5.     public CException(String message) {  
6.         super(message);  
7.     }  
8. }  

而后咱们撰写一个可能产生 CException 的 Class

[java]  view plain copy

1. public class TestException {  
2.     public void method1() throws CException {  
3.         throw new CException("Test Exception");  
4.     }  
5.   
6.     public void method2(String msg) {  
7.         if (msg == null) {  
8.             throw new NullPointerException("Message is null");  
9.         }  
10.     }  
11.   
12.     public void method3() throws CException {  
13.         method1();  
14.     }  
15.   
16.     // 如下省略  
17.     // ...  
18. }  

　在这三个method 中，咱们看到了method1 和method2 的程序码内都会产生Exception，但method3 的程序码中(大括号内)，并没产生Exception，但在method3 的定义中，暗示了这个method 可能产生CException。

　　呼叫method1() 的程序，必须将method1() 包含在try 与catch 中，如：

[java]  view plain copy

1. public class Runtest {  
2.     // ....  
3.     public static void main(String argv[]) {  
4.         TestException te = new TestException();  
5.         try {  
6.             te.method1();  
7.         } catch (CException ce) {  
8.             // ....  
9.             ce.printStackTrace();  
10.         }  
11.     }  
12.     // ...  
13. }  

虽然包含在try 与catch 中，并不表示这段程序码必定会收到CException，但它的用意在于提醒呼叫者，执行这个method 可能产生的意外，而使用者也必需要能针对这个意外作出相对应的处理方式。

　　当使用者呼叫method2() 时，并不须要使用try 和catch 将程序码包起来，由于method2 的定义中，并无throws 任何的Exception ，如：

[java]  view plain copy

1. public class Runtest  
2. {  
3. // ....  
4. public static void main(String argv[])  
5. {  
6.   
7. testException te = new testException();  
8.   
9. // 不会产生 Exception  
10. te.method2("Hello");  
11.   
12. // 会产生 Exception  
13. te.method2(null);  
14. }  
15. // ...  
16. }  

程序在执行的时候，也不见得会真的产生NullPointerException ，这种Exception 叫作runtime exception 也有人称为unchecked exception ，产生Runtime Exception 的method (在这个范例中是method2) 并不须要在宣告method 的时候定义它将会产生哪种Exception 。

　　在testException 的method3() 中，咱们看到了另一种情况，也就是method3里呼叫了method1() ，但却没有将method1 包在try 和catch 之间。相反，在method3() 的定义中，它定义了CException，实际上就是若是method3 收到了CException ，它将不处理这个CException ，而将它往外丢。固然，因为method3 的定义中有throws CException ，所以呼叫method3 的程序码也须要有try catch 才行。

　　所以从程序的运做机制上看，Runtime Exception与Checked Exception 不同，然而从逻辑上看，Runtime Exception 与Checked Exception 在使用的目的上也不同。

　　通常而言，Checked Exception 表示这个Exception 必需要被处理，也就是说程序设计者应该已经知道可能会收到某个Exception(由于要try catch住) ，因此程序设计者应该能针对这些不一样的Checked Exception 作出不一样的处理。

　　而Runtime Exception 一般会暗示着程序上的错误，这种错误会致使程序设计者没法处理，而形成程序没法继续执行下去。

看看下面的例子：

String message[] = {"message1", "message2","message3"};

System.out.println(message[3]);

　　这段程序码在Compile 时并没问题，但在执行时则会出现ArrayIndexOutOfBoundException 的例外，在这种情况下，咱们亦没法针对这个Runtime Exception 作出有意义的动做，这就像是咱们呼叫了testException 中的method2 ，却引起了它的NullPointerException 同样，在这种情况下，咱们必须对程序码进行修改，从而避免这个问题。

　　所以，实际上咱们应该也必需要去抓取全部的Checked Exception，同时最好能在这些Checked Exception 发生的时候作出相对应的处理，好让程序能面对不一样的情况。

　　然而对于Runtime Exception ，有些人建议将它catch 住，而后导向其它地方，让程序继续执行下去，这种做法并不是很差，但它会让咱们在某些测试工具下认为咱们的程序码没有问题，由于咱们将Runtime Exception "处理"掉了，事实却否则！譬如不少人的习惯是在程序的进入点后用个大大的try catch 包起来，如：

[html]  view plain copy

1. public class Runtest1 {  
2.     public static void main(String argv[]) {  
3.         try {  
4.             // ...  
5.         } catch (Exception e) {  
6.         }  
7.     }  
8. }  

在这种状况下，咱们极可能会不知道发生了什么Exception 或是从哪一行发出的，所以在面对不一样的Checked Exception时，咱们可已分别去try catch它。而在测试阶段时，若是碰到Runtime Exception ，咱们可让它就这样发生，接着再去修改咱们的程序码，让它避免Runtime Exception，不然，咱们就应该仔细追究每个Exception ，直到咱们能够肯定它不会有Runtime Exception 为止！

　　对于Checked Exception 与Runtime Exception ，我想应该有很多人会有不一样的观点，不管如何，程序先要能执行，这些Exception 才有机会产生。所以，咱们能够把这些Exception 当成是Bug ，也能够当成是不一样的情况(Checked Exception)，或当成是帮助咱们除错的工具(Runtime Exception)，但前提是咱们须要处理这些Exception ，若是不处理，那么问题或情况就会永远留在那里。

参考至：http://blog.csdn.net/liuj2511981/article/details/8524418