Assertions in Java
by Benoy Jose
Introduction
The advent of J2SE 1.4 saw the introduction of few important changes to
augment the power of java. Predominant among them are the java logging API,
Chained exceptions, Assertions and so on. To know more about them please refer
to the links below. In this article we shall explore the concept of assertions
and how they can add to the flexibility of the java language.
Assertions though a new concept introduced in the J2SE 1.4 specifications
have been a well established practice in the programming community from the ages of
the Eiffel programming language. Assertions, as stated above are not a new
concept introduced by java; they have been around for a number of years in many
object oriented programming languages. Assertions and exceptions derive
themselves from the concept of "Design by Contract," which is followed in most of
the object oriented languages. The design by contract theory states that an
application is created or designed according to a contract or specification
agreed upon by the creator and the consumer about the functioning of the
application. Vendors and implementers have been asking for assertions to be
included as a part of the specification. A good number of them have their
private implementations of assertions. Dr Dobbs journal has an article on how to
include your own assertions (See link below).
What are assertions?
To quote the text from the JSR 41 (Java Specification Request)
"An assertion is a statement containing a boolean expression that the
programmer believes to be true at the time the statement is executed". In other
words this means a facility provided within the java programming language to
test the correctness or assumptions made by your program. The assumptions could
be simple facts like a number cannot be negative or the range of a number is between
3.3 and 5.67. Assertions are checks provided within the system to ensure the
smooth running of the program.
Why Assertions:
The next obvious question that comes up is why we need another level of
checking when exceptions can do the job. Java exceptions are primarily used to
handle unusual conditions arising during program execution. Assertions are
used to specify conditions that a programmer assumes are true. When programming,
if a programmer can swear that the value being passed into a particular method
is positive no matter what a calling client passes, it can be documented using an
assertion to state it. Exceptions handle abnormal conditions arising in the
course of the program; however they do not guarantee smooth or correct execution
of the program. Assertions help state scenarios that ensure the program is
running smoothly. Assertions can be efficient tools to ensure correct execution
of a program. They improve the confidence about the program.
How to use Assertions:
The assertion statement has two forms.
assertExpression1;
assert Expression1:Expression2;
The first one is a simpler form that takes a boolean expression as an
argument. The expression is the one the programmer wishes to assert as true. If
the assumption fails, the expression evaluates to be false which means the
assertion failed. In case the expression succeeds the program continues normally.
The second form is the more descriptive one. The first argument takes a
Boolean expression, while the second expression would be the resulting action to
be taken if the assertion fails. The Expression2 should be a
value and can also be a result of executing a function. The compiler would
throw an error if the second expression returns a void value.
As discussed before an assertion is not a replacement for an exception and
cannot be used to show user level errors. User level errors need to be passed to
an appropriate error handler and they need be presented to the user more gracefully.
Assertions, like exceptions, throw an exception which would show them as part of
the stack trace.
When an assertion fails the program would throw an AssertionError on to the
stack trace. If the simpler form of assertion is used the program would create
an object of AssertionError with the default constructor, while in the second
form an object of AssertionError with the return type of Expression2.
The overloaded AssertionError constructor would then convert the
returned data type into String and dump it on the stack trace with a meaningful
message. A few examples are shown below.
assert i<0;
assert (!myString.equals(""));
assert age>0 : "The value of age cannot be negative +"age;
assert ((i/2*23-12)>0):checkArgumentValue();
assert isParameterValid():throwIllegalParameterError();
In the last example the method checkArgumentValue() must return a value.
Where to use Assertions:
As
we stated earlier, assertions are not to replace exceptions but to augment
them. Assertions should not be used at any place to ensure the smooth running of
a program. The fact that assertions can be turned off could make your programs
behave erratically.
Benoy Jose is a web developer with over six years of
experience in J2EE and Microsoft technologies. He is
a Sun Cetified programmer and enjoys writing technical
and non-technical articles for various magazines.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
| 
