Java中的异常

Java标准异常

Throwable这个类是Java中用老表示任何能够做为异常被抛出的基类,于是Java异常都是对象,是Throwable子类的实例,描述了出如今一段编码中的 错误条件。当条件生成时,错误将引起异常。html

Java异常类层次结构图:java

                                                                                图片来自:http://www.benchresources.net/exception-hierarchy-in-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。ui

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

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

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

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

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

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

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

处理异常机制

   在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。

        抛出异常:当一个方法出现错误引起异常时,方法建立异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

        捕获异常:在方法抛出异常以后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。

        对于运行时异常、错误或可查异常,Java技术所要求的异常处理方式有所不一样。

        因为运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,容许应用程序忽略运行时异常。

       对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java容许该方法不作任何抛出声明。由于,大多数Error异常属于永远不能被容许发生的情况,也属于合理的应用程序不应捕捉的异常。

       对于全部的可查异常,Java规定:一个方法必须捕捉,或者声明抛出方法以外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常。

        可以捕捉异常的方法,须要提供相符类型的异常处理器。所捕捉的异常,多是因为自身语句所引起并抛出的异常,也多是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,必定是Java代码在某处所抛出的异常。简单地说,异常老是先被抛出,后被捕捉的。

         任何Java代码均可以抛出异常,如:本身编写的代码、来自Java开发环境包中代码,或者Java运行时系统。不管是谁,均可以经过Java的throw语句抛出异常。

        从方法中抛出的任何异常都必须使用throws子句。

        捕捉异常经过try-catch语句或者try-catch-finally语句实现。

         整体来讲,Java规定:对于可查异常必须捕捉、或者声明抛出。容许忽略不可查的RuntimeException和Error。

关于try-catch-finally捕获异常时特殊状况说明

     1. finally中使用return语句,做为一个5年的.Net开发者,第一次知道finally中还能够加return,不过,不要惊讶!

                finally中的return语句将会覆盖方法原本的返回值,如下代码将永远返回false

 1 boolean testEx1(){  2     boolean ret = true;  3     try {  4         throw  new Exception();  //1  5         //return true; //2
 6     } catch (Exception e) {  7         System.out.println("testEx1, catch exception");  8         return true;  9     } finally { 10         System.out.println("testEx1, finally; return value=" + ret); 11         return false; 12  } 13 
14 }

             finally中使用return将会抑制异常的冒泡传输

finally中不使用return情形:

 1 public  static  void main(String[] args){  2     try {  3          boolean result= testEx2();  4          //System.out.println(result);
 5     } catch (Exception e) {  6         System.out.println("main, catch exception");  7     }  finally {  8         System.out.println("main, finally");  9  } 10 } 11 
12  static boolean testEx2() throws Exception { 13      boolean ret = true; 14      try { 15          int result = 1/0; 16          return true; 17      } catch (Exception e) { 18          System.out.println("testEx2, catch exception"); 19          ret = false; 20          throw e; 21      } finally { 22          System.out.println("testEx2, finally; return value=" + ret); 23          //return ret;
24  } 25 
26  }

输出:

finally中使用return情形

 1 static boolean testEx2() throws Exception {  2      boolean ret = true;  3      try {  4          int result = 1/0;  5          return true;  6      } catch (Exception e) {  7          System.out.println("testEx2, catch exception");  8          ret = false;  9          throw e; 10      } finally { 11          System.out.println("testEx2, finally; return value=" + ret); 12          return ret; 13  } 14 }

输出:

可见在testEx2方法finally中使用return时,main方法将捕获不到异常,main方法认为testEx2方法正常返回了。

     2.finally抛出异常

finally中抛出异常将会覆盖try-catch语句中抛出的异常

finally中不抛出异常情形:

 1 public  static  void main(String[] args){  2     try {  3          boolean result= testEx3();  4          //System.out.println(result);
 5     } catch (Exception e) {  6         System.out.println("main, catch exception"+e.getMessage());  7     }  finally {  8         System.out.println("main, finally");  9  } 10 } 11 static boolean testEx3() throws Exception { 12     boolean ret = true; 13     try { 14         int result = 1/0; 15         return true; 16     } catch (Exception e) { 17         System.out.println("testEx2, catch exception"); 18         ret = false; 19         throw new Exception("testEx2 catch: throw exception"); 20     } finally { 21         System.out.println("testEx2, finally: return value=" + ret); 22         //throw new Exception("testEx2, finally: throw exception");
23  } 24 
25 }

上面代码输出结果:

修改为在finally中抛出异常情形

 1 static boolean testEx3() throws Exception {  2     boolean ret = true;  3     try {  4         int result = 1/0;  5         return true;  6     } catch (Exception e) {  7         System.out.println("testEx2, catch exception");  8         ret = false;  9         throw new Exception("testEx2 catch: throw exception"); 10     } finally { 11         System.out.println("testEx2, finally: return value=" + ret); 12         throw new Exception("testEx2, finally: throw exception"); 13  } 14 
15 }

输出结果,与上面的状况对比能够发现,最终捕获的是finally中抛出的异常。

异常链

常常在捕获一个异常后又抛出另外一个异常,那么若是但愿将原来的异常信息保存下来,如何处理,这个时候就用到了异常链,在JDK1.4之前,程序员必须本身编写代码来保存原来的异常信息,如今全部Throwable的子类在构造器中均可以接受一个cause对象做为参数,这个cause就是用来保存原始异常信息,装经过把原始异常传递给新的异常,使得咱们能够根据这个异常连追中到异常最初发生的位置。

下面是一个简单示例:

 1 public  static  void main(String[] args){  2     try {  3  testEx5();  4     } catch (Exception e) {  5  e.printStackTrace();  6  }  7 }  8 
 9 static void testEx4() throws Exception{ 10 
11     try { 12         int result = 1/0; 13     } catch (Exception e) { 14         throw new Exception("testEx4发生异常",e); 15  } 16 } 17 
18 static void testEx5() throws Exception{ 19 
20     try { 21  testEx4(); 22     } catch (Exception e) { 23         throw new Exception("testEx5发生异常",e); 24  } 25 }

输出结果:

Java中常见异常

在Java中提供了一些异经常使用来描述常常发生的错误,对于这些异常,有的须要程序员进行捕获处理或声明抛出,有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类

1. RuntimeException子类

    java.lang.ArrayIndexOutOfBoundsException: 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

    java.lang.ArithmeticException:算术条件异常。譬如:整数除零等。

    java.lang.NullPointerException:空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等

    java.lang.ClassNotFoundException:找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH以后找不到对应名称的class文件时,抛出该异常。

   java.lang.NegativeArraySizeException:  数组长度为负异常

   java.lang.ArrayStoreException: 数组中包含不兼容的值抛出的异常

   java.lang.SecurityException: 安全性异常

   java.lang.IllegalArgumentException: 非法参数异常

2.IOException

  IOException:操做输入流和输出流时可能出现的异常。

  EOFException: 文件已结束异常 

  FileNotFoundException:文件未找到异常

3. 其余异常

  ClassCastException:类型转换异常类 

  ArrayStoreException:数组中包含不兼容的值抛出的异常

  SQLException:操做数据库异常类

  NoSuchFieldException:字段未找到异常

  NoSuchMethodException:方法未找到抛出的异常

  NumberFormatException:字符串转换为数字抛出的异常

  StringIndexOutOfBoundsException:字符串索引超出范围抛出的异常

  IllegalAccessException:不容许访问某类异常

  InstantiationException:当应用程序试图使用Class类中的newInstance()方法建立一个类的实例,而指定的类对象没法被实例化时,抛出该异常

 

参考:

http://www.benchresources.net/exception-hierarchy-in-java/

https://www.cnblogs.com/itcui/p/6400499.html

相关文章
相关标签/搜索