JAVA断言语句抛出的异常类属于什么类型
如题，请高手解答
09-02-24 &匿名提问
下面介绍一下断言在JAVA中的使用，JAVA是从JDK1.4才开始支持断言的（添加了关键字ASSERT）,请注意老版的JRE不支持。断言概述  编写代码时， 们总是会做出一些假设，断言就是用于在代码中捕捉这些假设  可以将断言看作是异常处理的一种高级形式  断言表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真  可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新起用断言。  使用断言可以创建更稳定，品质更好且易于除错的代码  当需要在一个值为FALSE时中断当前操作的话，可以使用断言  单元测试必须使用断言（JUNIT/JUNITX）  除了类型检查和单元测试外，断言还提供了一种确定个种特性是否在程序中得到维护的极好的方法  使用断言使 们向按契约式设计更近了一部常见的断言特性  前置条件断言：代码执行之前必须具备的特性  后置条件断言：代码执行之后必须具备的特性  前后不变断言：代码执行前后不能变化的特性断言使用方式  断言可以有两种形式  1.ASSERT EXPRESSION1  2.ASSERT EXPRESSION1:EXPRESSION2  其中EXPRESSION1应该总是一个布尔值，EXPRESSION2是断言失败时输出的失败消息的字符串。如果EXPRESSION1为假，则抛出一个 ASSERTIONERROR，这是一个错误，而不是一个异常，也就是说是一个不可控制异常（UNCHECKED EXCEPTION),ASSERTIONERROR由于是错误，所以可以不捕获，但不推荐这样做，因为那样会使你的系统进入不稳定状态。起用断言  断言在默认情况下是关闭的，要在编译时启用断言，需要使用SOURCE1.4标记 既JAVAC SOURCE1.4 TEST.JAVA ,在运行时启用断言需要使用 -EA参数 。要在系统类中启用和禁用断言可以使用 -ESA 和 -DSA参数。  例如： PUBLIC CLASS ASSERTEXAMPLEONE{   PUBLIC ASSERTEXAMPLEONE(){}   PUBLIC STATIC VOID MAIN(STRING ARGS[]){      INT X=10;      SYSTEM.OUT.PRINTLN(&TESTING ASSERTION THAT X==100&);      ASSERT X=100;&OUT ASSERTION FAILED!&;      SYSTEM.OUT.PRINTLN(&TEST PASSED!&);   }}如果编译时未加 -SOURCE1.4,则编译通不过在执行时未加 -EA 时输出为TESTING ASSERTION THAT X==100TEST PASSEDJRE忽略了断言的就代码，而使用了该参数就会输出为TESTING ASSERTION THAT X==100EXCEPTION IN THREAD &MAIN& JAVA.LANG.ASSERTIONERROR: OUT ASSERTION FAILED!        AT ASSERTEXAMPLEONE.MAIN(ASSERTEXAMPLEONE.JAVA:6)断言的副作用  由于程序员的问题，断言的使用可能会带来副作用 ，例如：  BOOLEAN ISENABLE=FALSE;  //...  ASSERT ISENABLE=TRUE;  这个断言的副作用是因为它修改了程序中变量的值并且未抛出错误，这样的错误如果不细心的检查是很难发现的。但是同时 们可以根据以上的副作用得到一个有用的特性，根据它来测试断言是否打开。 PUBLIC CLASS ASSERTEXAMPLETWO{   PUBLIC STATIC VOID MAIN(STRING ARGS[]){     BOOLEAN ISENABLE=FALSE;     //...     ASSERT ISENABLE=TRUE;     IF(ISENABLE==FALSE){       THROW NEW RUNTIMEEXCEPTION(&ASSERTION SHOULE BE ENABLE!&);     }   }}何时需要使用断言  1.可以在预计正常情况下程序不会到达的地方放置断言 ：ASSERT FALSE  2.断言可以用于检查传递给私有方法的参数。（对于公有方法，因为是提供给外部的接口，所以必须在方法中有相应的参数检验才能保证代码的健壮性）  3.使用断言测试方法执行的前置条件和后置条件  4.使用断言检查类的不变状态，确保任何情况下，某个变量的状态必须满足。（如AGE属性应大于0小于某个合适值）什么地方不要使用断言  断言语句不是永远会执行，可以屏蔽也可以启用因此：  1.不要使用断言作为公共方法的参数检查，公共方法的参数永远都要执行  2.断言语句不可以有任何边界效应，不要使用断言语句去修改变量和改变方法的返回值下边是介绍断言的用法:  ASSERT是在J2SE1.4中引入的新特性，ASSERTION就是在代码中包括的布尔型状态，程序员认为这个状态是TRUE。一般来说ASSERT在开发的时候是检查程序的安全性的，在发布的时候通常都不使用ASSERT。在1.4中添加了ASSERT关键字和JAVA.LANG.ASSERTERROR类的支持。
   首先， 们有必要从一个例子说起ASSERTPUBLIC CLASS ASSERTTEST{ PUBLIC STATIC VOID MAIN(STRING[] ARGS) {  ASSERTTEST AT = NEW ASSERTTEST();  AT.ASSERTME(TRUE);  AT.ASSERTME(FALSE);  
PRIVATE  VOID ASSERTME(BOOLEAN BOO) {  ASSERT BOO?TRUE:FALSE;
 SYSTEM.OUT.PRINTLN(&TRUE CONDITION&); } }程序中包含了ASSERT的话，你要用JAVAC -SOURCE 1.4 XXX.JAVA来编译，否则编译器会报错的。要想让ASSERT得部分运行的话，要使用JAVA -EA XXX来运行，否则包含ASSERT得行会被忽略。下面 们运行JAVAC -SOURCE 1.4 ASSERTTEST.JAVA JAVA -EA ASSERTTEST看看结果的输出是：TRUE CONDITIONEXCEPTION IN THREAD &MAIN& JAVA.LANG.ASSERTIONERROR        AT ASSERTTEST.ASSERTME(ASSERTTEST.JAVA:13)        AT ASSERTTEST.MAIN(ASSERTTEST.JAVA:7)当 们运行AT.ASSERTME(TRUE)得时候，由于ASSERT BOO?TRUE:FALSE相当于 ASSERT TRUE;因此没有任何问题，程序往下执行打印出TRUE CONDITION，但是执行AT.ASSERTME(FALSE)的时候相当于ASSERT FALSE，这个时候解释器就会抛出ASSERTIONERROR了，程序就终止了。大家必须清楚ASSERTIONERROR是继承自ERROR得，因此你可以不再程序中CATCH它的，当然你也可以在程序中CATCH它然后程序可以继续执行。例如：PUBLIC CLASS ASSERTTEST{ PUBLIC STATIC VOID MAIN(STRING[] ARGS) {  ASSERTTEST AT = NEW ASSERTTEST();  TRY  {   AT.ASSERTME(TRUE);   AT.ASSERTME(FALSE);  }  CATCH(ASSERTIONERROR AE)  {   SYSTEM.OUT.PRINTLN(&ASSERIONTERROR CATCHED&);
 }  SYSTEM.OUT.PRINTLN(&GO ON&);  
PRIVATE  VOID ASSERTME(BOOLEAN BOO) {  ASSERT BOO?TRUE:FALSE;
 SYSTEM.OUT.PRINTLN(&TRUE CONDITION&); } }    ASSERT还有另外一种表达的方式，就是ASSERT EXP1:EXP2;其中EXP1是个BOOLEAN返回值得表达式，而EXP2可以是原始的数据类型或者对象都可以例如：   BOOLEAN BOO = TRUE;   STRING STR = NULL;    ASSERT BOO = FALSE：STR=&ERROR&;         们刚开始讲得ASSERT EXP1得形式，当EXP1是FALSE得时候，ASSERTIONERROR得默认构造器会被调用，但是ASSERT EXP1:EXP2这样的形式，当EXP1为TRUE的时候后面EXP2被或略，如果FALSE的话，后面的表达式的结果会被计算出来并作为ASSERTIONERROR得构造器参数。看下面的例子：PUBLIC CLASS ASSERTTEST{ PUBLIC STATIC VOID MAIN(STRING[] ARGS) {  ASSERTTEST AT = NEW ASSERTTEST();  AT.ASSERTME(TRUE);  AT.ASSERTME(FALSE);  
PRIVATE  VOID ASSERTME(BOOLEAN BOO) {  STRING S = NULL;  ASSERT BOO?TRUE:FALSE:S = &HELLO WORLD&;
 SYSTEM.OUT.PRINTLN(&TRUE CONDITION&); } }运行的时候会得到这样的结果TRUE CONDITIONEXCEPTION IN THREAD &MAIN& JAVA.LANG.ASSERTIONERROR: HELLO WORLD        AT ASSERTTEST.ASSERTME(ASSERTTEST.JAVA:14)        AT ASSERTTEST.MAIN(ASSERTTEST.JAVA:7)ASSERT最好不要滥用，原因是ASSERT并不一定都是ENABLE的，下面两种情况就不应该用ASSERT不要再PUBLIC的方法里面检查参数是不是为NULL之类的操作例如PUBLIC INT GET(STRING S)   {       ASSERT S != NULL;   }如果需要检查也最好通过IF S = NULL 抛出NULLPOINTEREXCEPTION来检查 不要用ASSERT来检查方法操作的返回值来判断方法操作的结果   例如 ASSERT LIST.REMOVEALL();这样看起来好像没有问题 但是想想如果ASSERT 被DISABLE呢，那样他就不会被执行了 所以REMOVEALL()操作就没有被执行  可以这样代替BOOLEAN BOO = LIST.REMOVEAL();ASSERT BOO;就说这么多吧，ASSERT是SCJP1.4的考试内容 所以还是有必要了解的
请登录后再发表评论!
下面介绍一下断言在java中的使用，java是从jdk1.4才开始支持断言的（添加了关键字assert）,请注意老版的jre不支持。断言概述  编写代码时， 们总是会做出一些假设，断言就是用于在代码中捕捉这些假设  可以将断言看作是异常处理的一种高级形式  断言表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真  可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新起用断言。  使用断言可以创建更稳定，品质更好且易于除错的代码  当需要在一个值为false时中断当前操作的话，可以使用断言  单元测试必须使用断言（junit/junitx）  除了类型检查和单元测试外，断言还提供了一种确定个种特性是否在程序中得到维护的极好的方法  使用断言使 们向按契约式设计更近了一部常见的断言特性  前置条件断言：代码执行之前必须具备的特性  后置条件断言：代码执行之后必须具备的特性  前后不变断言：代码执行前后不能变化的特性断言使用方式  断言可以有两种形式  1.assert expression1  2.assert expression1:expression2  其中expression1应该总是一个布尔值，expression2是断言失败时输出的失败消息的字符串。如果expression1为假，则抛出一个 assertionerror，这是一个错误，而不是一个异常，也就是说是一个不可控制异常（unchecked exception),assertionerror由于是错误，所以可以不捕获，但不推荐这样做，因为那样会使你的系统进入不稳定状态。起用断言  断言在默认情况下是关闭的，要在编译时启用断言，需要使用source1.4标记 既javac source1.4 test.java ,在运行时启用断言需要使用 -ea参数 。要在系统类中启用和禁用断言可以使用 -esa 和 -dsa参数。  例如： public class assertexampleone{   public assertexampleone(){}   public static void main(string args[]){      int x=10;      system.out.println(&testing assertion that x==100&);      assert x=100;&out assertion failed!&;      system.out.println(&test passed!&);   }}如果编译时未加 -source1.4,则编译通不过在执行时未加 -ea 时输出为testing assertion that x==100test passedjre忽略了断言的就代码，而使用了该参数就会输出为testing assertion that x==100exception in thread &main& java.lang.assertionerror: out assertion failed!        at assertexampleone.main(assertexampleone.java:6)断言的副作用  由于程序员的问题，断言的使用可能会带来副作用 ，例如：  boolean isenable=  //...  assert isenable=  这个断言的副作用是因为它修改了程序中变量的值并且未抛出错误，这样的错误如果不细心的检查是很难发现的。但是同时 们可以根据以上的副作用得到一个有用的特性，根据它来测试断言是否打开。 public class assertexampletwo{   public static void main(string args[]){     boolean isenable=     //...     assert isenable=     if(isenable==false){       throw new runtimeexception(&assertion shoule be enable!&);     }   }}何时需要使用断言  1.可以在预计正常情况下程序不会到达的地方放置断言 ：assert false  2.断言可以用于检查传递给私有方法的参数。（对于公有方法，因为是提供给外部的接口，所以必须在方法中有相应的参数检验才能保证代码的健壮性）  3.使用断言测试方法执行的前置条件和后置条件  4.使用断言检查类的不变状态，确保任何情况下，某个变量的状态必须满足。（如age属性应大于0小于某个合适值）什么地方不要使用断言  断言语句不是永远会执行，可以屏蔽也可以启用因此：  1.不要使用断言作为公共方法的参数检查，公共方法的参数永远都要执行  2.断言语句不可以有任何边界效应，不要使用断言语句去修改变量和改变方法的返回值下边是介绍断言的用法:  assert是在j2se1.4中引入的新特性，assertion就是在代码中包括的布尔型状态，程序员认为这个状态是true。一般来说assert在开发的时候是检查程序的安全性的，在发布的时候通常都不使用assert。在1.4中添加了assert关键字和java.lang.asserterror类的支持。
   首先， 们有必要从一个例子说起assertpublic class asserttest{ public static void main(string[] args) {  asserttest at = new asserttest();  at.assertme(true);  at.assertme(false);  
private  void assertme(boolean boo) {  assert boo?true:
 system.out.println(&true condition&); } }程序中包含了assert的话，你要用javac -source 1.4 xxx.java来编译，否则编译器会报错的。要想让assert得部分运行的话，要使用java -ea xxx来运行，否则包含assert得行会被忽略。下面 们运行javac -source 1.4 asserttest.java java -ea asserttest看看结果的输出是：true conditionexception in thread &main& java.lang.assertionerror        at asserttest.assertme(asserttest.java:13)        at asserttest.main(asserttest.java:7)当 们运行at.assertme(true)得时候，由于assert boo?true:false相当于因此没有任何问题，程序往下执行打印出true condition，但是执行at.assertme(false)的时候相当于assert false，这个时候解释器就会抛出assertionerror了，程序就终止了。大家必须清楚assertionerror是继承自error得，因此你可以不再程序中catch它的，当然你也可以在程序中catch它然后程序可以继续执行。例如：public class asserttest{ public static void main(string[] args) {  asserttest at = new asserttest();  try  {   at.assertme(true);   at.assertme(false);  }  catch(assertionerror ae)  {   system.out.println(&asserionterror catched&);
 }  system.out.println(&go on&);  
private  void assertme(boolean boo) {  assert boo?true:
 system.out.println(&true condition&); } }    assert还有另外一种表达的方式，就是assert exp1:exp2;其中exp1是个boolean返回值得表达式，而exp2可以是原始的数据类型或者对象都可以例如：   boolean boo =   string str =    assert boo = false：str=&error&;         们刚开始讲得assert exp1得形式，当exp1是false得时候，assertionerror得默认构造器会被调用，但是assert exp1:exp2这样的形式，当exp1为true的时候后面exp2被或略，如果false的话，后面的表达式的结果会被计算出来并作为assertionerror得构造器参数。看下面的例子：public class asserttest{ public static void main(string[] args) {  asserttest at = new asserttest();  at.assertme(true);  at.assertme(false);  
private  void assertme(boolean boo) {  string s =  assert boo?true:false:s = &hello world&;
 system.out.println(&true condition&); } }运行的时候会得到这样的结果true conditionexception in thread &main& java.lang.assertionerror: hello world        at asserttest.assertme(asserttest.java:14)        at asserttest.main(asserttest.java:7)assert最好不要滥用，原因是assert并不一定都是enable的，下面两种情况就不应该用assert不要再public的方法里面检查参数是不是为null之类的操作例如public int get(string s)   {       assert s !=   }如果需要检查也最好通过if s = null 抛出nullpointerexception来检查 不要用assert来检查方法操作的返回值来判断方法操作的结果   例如 assert list.removeall();这样看起来好像没有问题 但是想想如果assert 被disable呢，那样他就不会被执行了 所以removeall()操作就没有被执行  可以这样代替boolean boo = list.removeal();就说这么多吧，assert是scjp1.4的考试内容 所以还是有必要了解的
请登录后再发表评论!Java运行时异常和非运行时异常
时间： 15:00:30
&&&& 阅读：34
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&1.异常机制
Java把异常当做对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。Java中的异常分为两大类：错误Error和异常Exception，Java异常体系结构如下图所示：
图片来源：http://blog.csdn/wuwenxiang91322/article/details/
2.Throwable
Throwable类是所有异常或错误的超类，它有两个子类：Error和Exception，分别表示错误和异常。其中异常Exception分为运行时异常(RuntimeException)和非运行时异常，也称之为不检查异常(Unchecked Exception)和检查异常(Checked Exception)。
一般是指java虚拟机相关的问题，如系统崩溃、虚拟机出错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致应用程序中断，通常应用程序无法处理这些错误，因此应用程序不应该捕获Error对象，也无须在其throws子句中声明该方法抛出任何Error或其子类。
4.可查异常和不可查异常
通常，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。可查异常（编译器要求必须处置的异常）：正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。不可查异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。
如果使用throw在方法体中抛出可查异常，则需要在方法头部声明方法可能抛出的异常类型。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
5.运行时异常和非运行时异常
(1)运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
当出现RuntimeException的时候，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。&出现运行时异常后，如果没有捕获处理这个异常（即没有catch），系统会把异常一直往上层抛，一直到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被catch块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。&如果不想终止，则必须捕获所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。
(2)非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。如IOException、SQLException等以及用户自定义的Exception异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch并处理，否则程序就不能编译通过。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。
6.finally关键字
来看看下面这个test1()方法：
public&int&test1()&{&&
&&&&&&&&try&{&&
&&&&&&&&&&&&return&1;&&
&&&&&&&&}&finally&{&&
&&&&&&&&&&&&return&2;&&
&&&&&&&&}&&
方法test1将返回2；
怎么解释呢？再来看看下面这个test2()方法：
public&int&test2()&{&&
&&&&&&&&int&i&=&1;&&
&&&&&&&&try&{&&
&&&&&&&&&&&&System.out.println("try语句块中");&&
&&&&&&&&&&&&return&1;&&
&&&&&&&&}&finally&{&&
&&&&&&&&&&&&System.out.println("finally语句块中");&&
&&&&&&&&&&&&return&2;&&
&&&&&&&&}&&
运行结果是：
try语句块中finally语句块中2
从运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
常见RuntimeException：
ArrayStoreException & & & & & & & &试图将错误类型的对象存储到一个对象数组时抛出的异常ClassCastException & & & & & & & &试图将对象强制转换为不是实例的子类时，抛出该异常IllegalArgumentException & & & & 抛出的异常表明向方法传递了一个不合法或不正确的参数IndexOutOfBoundsException & 指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出NoSuchElementException & & & 表明枚举中没有更多的元素NullPointerException & & & & & & & &当应用程序试图在需要对象的地方使用 null 时，抛出该异常
参考资料：
&标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文：/diegodu/p/7298882.html
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！Java有无办法在捕获异常后从异常语句继续往下执行？ - 知乎2被浏览1757分享邀请回答0添加评论分享收藏感谢收起今天遇到一个问题，在下面的代码中，当抛出运行时异常后，后面的代码还会执行吗，是否需要在异常后面加上return语句呢？
public void add(int index, E element){
if(size &= elements.length) {
throw new RuntimeException(&顺序表已满，无法添加&);
//需要吗？
为了回答这个问题，我编写了几段代码测试了一下，结果如下：
public static void test() throws Exception
throw new Exception(&参数越界&);
System.out.println(&异常后&); //编译错误，「无法访问的语句」
throw new Exception(&参数越界&);
}catch(Exception e) {
e.printStackTrace();
System.out.println(&异常后&);//可以执行
if(true) {
throw new Exception(&参数越界&);
System.out.println(&异常后&); //抛出异常，不会执行
若一段代码前有异常抛出，并且这个异常没有被捕获，这段代码将产生编译时错误「无法访问的语句」。如代码1
若一段代码前有异常抛出，并且这个异常被try...catch所捕获，若此时catch语句中没有抛出新的异常，则这段代码能够被执行，否则，同第1条。如代码2
若在一个条件语句中抛出异常，则程序能被编译，但后面的语句不会被执行。如代码3
另外总结一下运行时异常与非运行时异常的区别：
运行时异常是RuntimeException类及其子类的异常，是非受检异常，如NullPointerException、IndexOutOfBoundsException等。由于这类异常要么是系统异常，无法处理，如网络问题；
要么是程序逻辑错误，如空指针异常；JVM必须停止运行以改正这种错误，所以运行时异常可以不进行处理（捕获或向上抛出，当然也可以处理），而由JVM自行处理。Java Runtime会自动catch到程序throw的RuntimeException，然后停止线程，打印异常。
非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类，是受检异常。非运行时异常必须进行处理（捕获或向上抛出），如果不处理，程序将出现编译错误。一般情况下，API中写了throws的Exception都不是RuntimeException。
常见运行时异常：
常见非运行时异常：
阅读(...) 评论()