Flow of Control - Java - page 122

(Note that there is no case where two operators have equal precedence but one asso-
ciates from left to right while the other associates from right to left. That must be true
or else there would be cases with conflicting instructions for inserting parentheses.)
The association of operands with operators is called binding . For example,
when parentheses determine which two expressions (two operands) are being
added by a particular + sign, that is called binding the two operands to the + sign.
A fully parenthesized expression accomplishes binding for all the operators in an
expression.
These examples should make it clear that it can be risky to depend too heavily on
the precedence and associativity rules. It is best to include most parentheses and
only omit parentheses in situations where the intended meaning is very obvious,
such as a simple combination of * and + , or a simple chain of && 's or a simple chain
of || 's. The following examples have some omitted parentheses, but their meaning
should be clear:

binding

rate * time + lead
(time < limit) && (yourScore > theirScore) && (yourScore > 0)
(expenses < income) || (expenses < savings) || (creditRating > 0)

Notice that the precedence rules include both arithmetic operators such as + and *
as well as Boolean operators such as && and || . This is because many expressions com-
bine arithmetic and Boolean operations, as in the following simple example:

(number + 1) > 2 || (number + 5) < -3

If you check the precedence rules given in Display 3.6, you will see that this expression
is equivalent to

(((number + 1) > 2) || ((number + 5) < (-3)))

because > and < have higher precedence than || . In fact, you could omit all the
parentheses in the above expression and it would have the same meaning (but would
be less clear).
It might seem that once an expression is fully parenthesized, the meaning of the
expression is then determined. It would seem that to evaluate the expression, you (or
the computer) simply evaluate the inner expressions before the outer ones. So, in

((number + 1) > 2) || ((number + 5) < (-3))

first the expressions (number + 1) , (number + 5) , and (-3) are evaluated (in any order),
then the > and < are evaluated, and then the || is applied. That happens to work in this
simple case. In this case, it does not matter which of (number + 1) , (number + 5) , and
(-3) is evaluated first, but in certain other expressions it will be necessary to specify
which subexpression is evaluated first. The rules for evaluating a fully parenthesized
expression are (and indeed must be) more complicated than just evaluating inner expres-
sions before outer expressions.