Java异常

时间 2019-12-13

标签 java 异常栏目 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()就能得到原始异常。

》建议

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