您的位置:

是否可以断言像java,什么是断言,断言有什么作用?

本文目录一览:

Java开发中什么时候使用断言?

Myeclipse中单元测试断言例子:

首先,建立Web Project,工程名为:JunitDemo,我选择的是Java EE 5。

然后建立包,包名为:demotest。

其次,在包下面建立一个Java CLass,也就是Java类,类名为:JunitDemo

下一步是在JunitDemo.java上面点击右键----NEW----OTHER,然后找到Java------JUint,然后里面就选择JUint Test Case。

如图:

这里,setup和teardown打上勾。

包就选择demotest,这样就和JuintDemo在一个包下面,Name就写 JunitDemoTest,好了。点击FINISH完成。,这个过程中就会自动安装Junit  3的包。

JunitDemoTest.java的内容为:

package demotest;

import junit.framework.TestCase;

public class JunitDemoTest extends TestCase {

protected void setUp() throws Exception {

super.setUp();

}

protected void tearDown() throws Exception {

super.tearDown();

}

public void testReturnstring() {

JunitDemo jd = new JunitDemo();

this.assertEquals("I'm good", jd.returnstring());

}

public static void main(String args[]){

System.out.println("测试环境。");

}

}

然后就是RUN   as- -- Junit Test。这是看结果就好了,进度条为绿色就表示为,通过了,红色就是没有通过。

如图:

在Java中怎么使用断言

如果要开启断言检查,则需要用开关-enableassertions或-ea来开启。

assert关键字语法很简单,有两种用法:

1、assert boolean表达式

如果boolean表达式为true,则程序继续执行。

如果为false,则程序抛出AssertionError,并终止执行。

2、assert boolean表达式 : 错误信息表达式

如果boolean表达式为true,则程序继续执行。

如果为false,则程序抛出java.lang.AssertionError,并输入错误信息表达式。

三、应用实例

下面给出一个例子,通过例子说明其用法:

public class AssertFoo {

public static void main(String args[]) {

//断言1结果为true,则继续往下执行

assert true;

System.out.println("断言1没有问题,Go!");

System.out.println("\n-----------------\n");

//断言2结果为false,程序终止

assert false : "断言失败,此表达式的信息将会在抛出异常的时候输出!";

System.out.println("断言2没有问题,Go!");

}

}

保存代码到C:\AssertFoo.java,然后按照下面的方式执行,查看控制台输出结果:

1、编译程序:

C:\javac AssertFoo.java

2、默认执行程序,没有开启-ea开关:

C:\java AssertFoo

断言1没有问题,Go!

-----------------

断言2没有问题,Go!

3、开启-ea开关,执行程序:

C:\java -ea AssertFoo

断言1没有问题,Go!

-----------------

Exception in thread "main" java.lang.AssertionError: 断言失败,此表达式的信息将

会在抛出异常的时候输出!

at AssertFoo.main(AssertFoo.java:10)

四、陷阱

assert关键字用法简单,但是使用assert往往会让你陷入越来越深的陷阱中。应避免使用。笔者经过研究,总结了以下原因:

1、assert关键字需要在运行时候显式开启才能生效,否则你的断言就没有任何意义。而现在主流的Java IDE工具默认都没有开启-ea断言检查功能。这就意味着你如果使用IDE工具编码,调试运行时候会有一定的麻烦。并且,对于Java Web应用,程序代码都是部署在容器里面,你没法直接去控制程序的运行,如果一定要开启-ea的开关,则需要更改Web容器的运行配置参数。这对程序的移植和部署都带来很大的不便。

2、用assert代替if是陷阱之二。assert的判断和if语句差不多,但两者的作用有着本质的区别:assert关键字本意上是为测试调试程序时使用的,但如果不小心用assert来控制了程序的业务流程,那在测试调试结束后去掉assert关键字就意味着修改了程序的正常的逻辑。

3、assert断言失败将面临程序的退出。这在一个生产环境下的应用是绝不能容忍的。一般都是通过异常处理来解决程序中潜在的错误。但是使用断言就很危险,一旦失败系统就挂了。

五、对assert的思考

assert既然是为了调试测试程序用,不在正式生产环境下用,那应该考虑更好的测试JUint来代替其做用,JUint相对assert关键的所提供的功能是有过之而无不及。当然完全可以通过IDE debug来进行调试测试。在此看来,assert的前途一片昏暗。

因此,应当避免在Java中使用assert关键字,除非哪一天Java默认支持开启-ea的开关,这时候可以考虑。对比一下,assert能给你带来多少好处,多少麻烦,这是我们选择是否使用的的原则。

以上仅仅代表我个人观点,欢迎大家留言讨论。

-----------------------------------------------------------------------------------

下面是一些Assert的例子:

assert 0 value;

assert 0 value:"value="+value;

assert ref != null:"ref doesn''t equal null";

assert isBalanced();

-----------------------------------------------------------------------------------

AssertinError类是Error的直接子类,因此代表程序出现了严重的错误,这种异常通常是不需要程序员使用catch语句捕捉的。

使用assert的准则:assert语句的作用是保证程序内部的一致性,而不是用户与程序之间的一致性,所以不应用在保证命令行参数的正确性。可以用来保证传递给private方法参数的正确性。因为私有方法只是在类的内部被调用,因而是程序员可以控制的,我们可以预期它的状态是正确和一致的。公有方法则不适用。此外,assert语句可用于检查任何方法结束时状态的正确性,及在方法的开始检查相关的初始状态 等等。

assert语句并不构成程序正常运行逻辑的一部分,时刻记住在运行时它们可能不会被执行。

-----------------------------------------------------------------------------------

两类参数:

参数 -esa和 -dsa:

它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中,也使了 assertion语句,因此如果用户需要观察它们的运行情况,就需要打开系统类的assertion功能 ,我们可使用-esa参数打开,使用 -dsa参数关闭。 -esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions,全名和缩写名有同样的功能。

参数 -ea和 -ea:

它们含义为开启(关闭)用户类的assertion功能:通过这个参数,用户可以打开某些类或包的assertion功能,同样用户也可以关闭某些类和包的assertion功能。打开assertion功能参数为-ea;如果不带任何参数,表示打开所有用户类;如果带有包名称或者类名称,表示打开这些类或包;如果包名称后面跟有三个点,代表这个包及其子包;如果只有三个点,代表无名包。关闭 assertion功能参数为-da,使用方法与-ea类似。

-ea和-da的全名为-enableassertions和-disenableassertions,全名和缩写名有同样的功能。

下面表格表示了参数及其含义,并有例子说明如何使用。

参数 例子 说明

-ea java -ea 打开所有用户类的assertion

-da java -da 关闭所有用户类的assertion

-ea: java -ea:MyClass1 打开MyClass1的assertion

-da: java -da: MyClass1 关闭MyClass1的assertion

-ea: java -ea:pkg1 打开pkg1包的assertion

-da: java -da:pkg1 关闭pkg1包的assertion

-ea:... java -ea:... 打开缺省包(无名包)的assertion

-da:... java -da:... 关闭缺省包(无名包)的assertion

-ea:... java -ea:pkg1... 打开pkg1包和其子包的assertion

-da:... java -da:pkg1... 关闭pkg1包和其子包的assertion

-esa java -esa 打开系统类的assertion

-dsa java -dsa 关闭系统类的assertion

-----------------------------------------------------------------------------------

不要再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;

-----------------------------------------------------------------------------------

另外,Java为了让程序也能够动态开启和关闭某些类和包的assertion功能,Java修该了Class和ClassLoader的实现,增加了几个用于操作assert的API。下面简单说明一下几个API的作用。

ClassLoader类中的几个相关的API:

setDefaultAssertionStatus:用于开启/关闭assertion功能

setPackageAssertionStatus:用于开启/关闭某些包的assertion功能

setClassAssertionStatus: 用于开启/关闭某些类的assertion功能

clearAssertionStatus:用于关闭assertion功能

程序设计里面的断言是什么???Java里面的assert,assert.h又是什么???

(一)首先明确:

java断言Assert是jdk1.4引入的。

jvm 断言默认是关闭的。

断言是可以局部开启的,如:父类禁止断言,而子类开启断言,所以一般说“断言不具有继承性”。

断言只适用于复杂的调试过程。

断言一般用于程序执行结果的判断,千万不要让断言处理业务流程。

(二)判断eclipse是否开启了断言,代码如下:

public class AssertTest {

public static void main(String[] args) {

boolean isOpen = false;

assert isOpen=true; //如果开启了断言,会将isOpen的值改为true

System.out.println(isOpen);//打印是否开启了断言

}

}

执行上面代码,如果打印 true说明已经启用了断言,如果为 false 则没有启用断言。

如果没有启用断言,则按按照下面方法开启断言。

(三)eclipse中开启断言

选择菜单:Run --- Run... --- 选择 Arguments 选项卡

在 VM arguments 文本框中输入: -ea 注意 中间没有空格,如果输入 -da 表示禁止断言。

然后关闭该窗口,提示保存,然后保存就开启了断言。如下图:

再次执行第二步操作,如果打印true,说明开启断言成功。

如果禁止断言,则按第二步操作中,删除 -ea 或者将 -ea 改为 -da 即可。

(四)断言使用

第 1 种使用方法:

public static void main(String[] args) {

boolean isOk = 12;

assert isOk;

System.out.println("程序正常");

}

因为 12 显然是错误的,所以执行结果抛出异常:Exception in thread "main" java.lang.AssertionError

如果把 12 改为 12 则程序能顺利执行,打印 “程序正常”

第 2 种使用方法:

public static void main(String[] args) {

boolean isOk = 12;

try{

assert isOk : "程序错误";

System.out.println("程序正常");

}catch(AssertionError err){

System.out.println(err.getMessage());

}

}

assert 后面跟个冒号表达式。如果冒号前为 true,则冒号后面的被忽略。

如果冒号前为false,则抛出AssertionError , 错误信息内容为冒号后面的内容,上面程序执行结果就是打印:"程序错误"

(五)有关断言的更多参数:

-ea java -ea 打开所有用户类的assertion

-da java -da 关闭所有用户类的assertion

-ea:classname java -ea:MyClass1 打开MyClass1的assertion

-da:classname java -da: MyClass1 关闭MyClass1的assertion

-ea:packagename java -ea:pkg1 打开pkg1包的assertion

-da:packagename java -da:pkg1 关闭pkg1包的assertion

-ea:... java -ea:... 打开缺省包(无名包)的assertion

-da:... java -da:... 关闭缺省包(无名包)的assertion

-ea:packagename... java -ea:pkg1... 打开pkg1包和其子包的assertion

-da:packagename... java -da:pkg1... 关闭pkg1包和其子包的assertion

-esa java -esa 打开系统类的assertion

-dsa java -dsa 关闭系统类的assertion

综合使用 java -dsa:MyClass1:pkg1 关闭MyClass1和pkg1包的assertion

java中的断言问题

下面介绍一下断言在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==100

Test passed

jre忽略了断言的就代码,而使用了该参数就会输出为

Testing Assertion that x==100

Exception 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类的支持。

首先,我们有必要从一个例子说起assert

public 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 condition

Exception 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 condition

Exception 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断言的用途?

断言是在Java1.4中引入的。它能让验证假设。如果断言失败(即返回false),就会抛出AssertionError(如果启用断言)。

Java中断言的用法

第一步:定义一个断言,如:

int number=-28; assert (number0):"负数不能计算平方根";//此断言是假的,所以会输出后面内容,之后会报错

第二步:在断言的类中右击选择“Run As”,之后选择” Run Configuration“;

第三步:选择 Arguments 选项卡;

第四步:在 VM arguments 文本框中输入” -ea“来运行断言;

输出结果: