Java Reference
In-Depth 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
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 short-circuit 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 non-Java “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 short-circuit evaluation; it is defined as:
b||c is equivalent to: b ? true : c
Short-circuit 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-
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 short-circuit mode. For
example, evaluation of n=0|x/0=5 causes a division-by-zero exception,
while evaluation of n=0||x/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