Java Reference
InDepth Information
The first operand,
n!=0
, evaluates to
false
. Since
&&
with a
false
operand
evaluates to
false
regardless of the value of the other operand, evaluation of the
expression terminates with the value
false
—without evaluating the second
operand.
Now evaluate the expression but with the operands of the conjunction
exchanged (in a state in which
n
is
0
):
10/n>2 && n!=0
Since
n
is
0
, evaluation of
10 / n
causes execution of the program to abort.
Division by
0
is not allowed.
Thus, changing the order of the operands in a conjunction can change the
value of the conjunction.
Evaluation of a conjunction
b&&c
is done using
shortcircuit evaluation
: if
the first operand
b
is
false
, the result
false
is obtained without evaluating the
second operand.
We can give a definition of
&&
using a nonJava “conditional expression”:
b&&c
is equivalent to:
(
if
b
then
c
else false
)
which has the meaning: if
b
is
true
, then the result is whatever
c
is; otherwise,
the result is
false
. Actually, Java has such a conditional expression with a dif
ferent notation, and we can define
b&&c
as:
b&&c
is equivalent to:
b ? c :
false
In a similar fashion, disjunction

uses shortcircuit evaluation; it is defined as:
bc
is equivalent to:
b ?
true
: c
Shortcircuit evaluation is used to protect an operation that might be unde
fined in some states from being evaluated in those states. You have seen one
example of this: protection against division by
0
. Another operation that may
need protection is referencing an element of an array because the subscript may
not be in the range of the array. A third situation is protection against referring to
a field of a nonexistent object. Here are the schemas for these boolean expres
sions:
if
(n != 0 && (
boolean expression involving division by
n)) …
if
(n < b.length && (
boolean expression involving
b[n])) …
if
(obj !=
null
&& (
boolean expression involving
obj.f)) …
Do not use

and
&
. Java has two “bit” operators,

and
&
, which in many situations give the same
result as

and
&&.
However, they are not evaluated in shortcircuit mode. For
example, evaluation of
n=0x/0=5
causes a divisionbyzero exception,
while evaluation of
n=0x/0=5
does not. The moral of this story is: stay
away from

and
&
and use

and
&&
, unless you really are in a situation where

or
&
are required.
Search WWH ::
Custom Search