Java异常

 

 

Java异常框架

Java异常架构图数组

 

 

 

 

 

 

1. Throwable
  Throwable是 Java 语言中全部错误或异常的超类。
  Throwable包含两个子类: Error 和 Exception。它们一般用于指示发生了异常状况。
  Throwable包含了其线程建立时线程执行堆栈的快照,它提供了printStackTrace()等接口用于获取堆栈跟踪数据等信息。架构

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

3. RuntimeException 
  RuntimeException是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
  编译器不会检查RuntimeException异常。例如,除数为零时,抛出ArithmeticException异常。RuntimeException是ArithmeticException的超类。当代码发生除数为零的状况时,假若既"没有经过throws声明抛出ArithmeticException异常",也"没有经过try...catch...处理该异常",也能经过编译。这就是咱们所说的"编译器不会检查RuntimeException异常"!
  若是代码会产生RuntimeException异常,则须要经过修改代码进行避免。例如,若会发生除数为零的状况,则须要经过代码避免该状况的发生!ide

4. Error
  和Exception同样,Error也是Throwable的子类。它用于指示合理的应用程序不该该试图捕获的严重问题,大多数这样的错误都是异常条件。
  和RuntimeException同样,编译器也不会检查Error。this

  它是程序没法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操做无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 再也不有继续执行操做所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)通常会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,由于它们在应用程序的控制和处理能力之 外,并且绝大多数是程序运行时不容许出现的情况。对于设计合理的应用程序来讲,即便确实发生了错误,本质上也不该该试图去处理它所引发的异常情况。在 Java中,错误经过Error的子类描述。编码

 

Java将可抛出(Throwable)的结构分为三种类型:被检查的异常(Checked Exception),运行时异常(RuntimeException)和错误(Error)。(01) 运行时异常spa

定义: RuntimeException及其子类都被称为运行时异常。
特色: Java编译器不会检查它。也就是说,当程序中可能出现这类异常时,假若既"没有经过throws声明抛出它",也"没有用try-catch语句捕获它",仍是会编译经过。例如,除数为零时产生的ArithmeticException异常,数组越界时产生的IndexOutOfBoundsException异常,fail-fail机制产生的ConcurrentModificationException异常等,都属于运行时异常。
  虽然Java编译器不会检查运行时异常,可是咱们也能够经过throws进行声明抛出,也能够经过try-catch对它进行捕获处理。
  若是产生运行时异常,则须要经过修改代码来进行避免。例如,若会发生除数为零的状况,则须要经过代码避免该状况的发生!
线程

(02) 被检查的异常
定义: Exception类自己,以及Exception的子类中除了"运行时异常"以外的其它子类都属于被检查异常。
特色: Java编译器会检查它。此类异常,要么经过throws进行声明抛出,要么经过try-catch进行捕获处理,不然不能经过编译。例如,CloneNotSupportedException就属于被检查异常。当经过clone()接口去克隆一个对象,而该对象对应的类没有实现Cloneable接口,就会抛出CloneNotSupportedException异常。
  被检查异常一般都是能够恢复的。设计

(03) 错误
定义: Error类及其子类。
特色: 和运行时异常同样,编译器也不会对错误进行检查。
  当资源不足、约束失败、或是其它程序没法继续运行的条件发生时,就产生错误。程序自己没法修复这些错误的。例如,VirtualMachineError就属于错误。
  按照Java惯例,咱们是不该该是实现任何新的Error子类的!指针

对于上面的3种结构,咱们在抛出异常或错误时,到底该哪种?《Effective Java》中给出的建议是:对于能够恢复的条件使用被检查异常,对于程序错误使用运行时异常。

 

    在 Java 中,全部的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制经过 Java 应用程序传输的任何问题的共性。
       Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),两者都是 Java 异常处理的重要子类,各自都包含大量子类。

       Error(错误):是程序没法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操做无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 再也不有继续执行操做所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)通常会选择线程终止。

。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,由于它们在应用程序的控制和处理能力之 外,并且绝大多数是程序运行时不容许出现的情况。对于设计合理的应用程序来讲,即便确实发生了错误,本质上也不该该试图去处理它所引发的异常情况。在 Java中,错误经过Error的子类描述。

       Exception(异常):是程序自己能够处理的异常。

       Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 经常使用操做”引起的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引起运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。

   注意:异常和错误的区别:异常能被程序自己能够处理,错误是没法处理。

   一般,Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。
      可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常情况。可查异常虽然是异常情况,但在必定程度上它的发生是能够预计的,并且一旦发生这种异常情况,就必须采起某种方式进行处理。

      除了RuntimeException及其子类之外,其余的Exception类及其子类都属于可查异常。这种异常的特色是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,不然编译不会经过。

     不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。

     Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽量去处理这些异常。

       运行时异常:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中能够选择捕获处理,也能够不处理。这些异常通常是由程序逻辑错误引发的,程序应该从逻辑角度尽量避免这类异常的发生。

      运行时异常的特色是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即便没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译经过。
       非运行时异常 (编译异常):是RuntimeException之外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,若是不处理,程序就不能编译经过。如IOException、SQLException等以及用户自定义的Exception异常,通常状况下不自定义检查异常。

 

最后,咱们来看看怎么使用自定义异常:

在 Java 中你能够自定义异常。编写本身的异常类时须要记住下面的几点。

  • 全部异常都必须是 Throwable 的子类。
  • 若是但愿写一个检查性异常类,则须要继承 Exception 类。
  • 若是你想写一个运行时异常类,那么须要继承 RuntimeException 类。

能够像下面这样定义本身的异常类:

class MyException extends Exception{ }

 

咱们来看一个实例:

 1 package com.hysum.test;
 2 
 3 public class MyException extends Exception {
 4      /**
 5      * 错误编码
 6      */
 7     private String errorCode;
 8 
 9    
10     public MyException(){}
11     
12     /**
13      * 构造一个基本异常.
14      *
15      * @param message
16      *        信息描述
17      */
18     public MyException(String message)
19     {
20         super(message);
21     }
22 
23    
24 
25     public String getErrorCode() {
26         return errorCode;
27     }
28 
29     public void setErrorCode(String errorCode) {
30         this.errorCode = errorCode;
31     }
32 
33     
34 }

使用自定义异常抛出异常信息:

 1 package com.hysum.test;
 2 
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         String[] sexs = {"男性","女性","中性"};
 8                   for(int i = 0; i < sexs.length; i++){
 9                       if("中性".equals(sexs[i])){
10                           try {
11                             throw new MyException("不存在中性的人!");
12                         } catch (MyException e) {
13                             // TODO Auto-generated catch block
14                             e.printStackTrace();
15                         }
16                      }else{
17                          System.out.println(sexs[i]);
18                      }
19                 } 
20     }
21 
22 }

 1 package com.hysum.test;
 2 
 3 public class Main {
 4     public void test1() throws RuntimeException{
 5         String[] sexs = {"男性","女性","中性"};
 6         for(int i = 0; i < sexs.length; i++){
 7             if("中性".equals(sexs[i])){
 8                 try {
 9                     throw new MyException("不存在中性的人!");
10                 } catch (MyException e) {
11                     // TODO Auto-generated catch block
12                     e.printStackTrace();
13                     RuntimeException rte=new RuntimeException(e);//包装成RuntimeException异常
14                     //rte.initCause(e);
15                     throw rte;//抛出包装后的新的异常
16                 }
17            }else{
18                System.out.println(sexs[i]);
19            }
20       } 
21     }
22     public static void main(String[] args) {
23         // TODO Auto-generated method stub
24         Main m =new Main();
25         
26         try{
27         m.test1();
28         }catch (Exception e){
29             e.printStackTrace();
30             e.getCause();//得到原始异常
31         }
32         
33     }
34 
35 }

运行结果:

结果分析:咱们能够看到控制台先是输出了原始异常,这是由e.getCause()输出的;而后输出了e.printStackTrace(),在这里能够看到Caused by:原始异常和e.getCause()输出的一致。这样就是造成一个异常链。initCause()的做用是包装原始的异常,当想要知道底层发生了什么异常的时候调用getCause()就能得到原始异常。 

》建议

异常须要封装和传递,咱们在进行系统开发的时候,不要“吞噬”异常,也不要“赤裸裸”的抛出异常,封装后在抛出,或者经过异常链传递,能够达到系统更健壮、友好的目的。

相关文章
相关标签/搜索