The Java Language Specification, Third Edition

EXPRESSIONS Evaluation Respects Parentheses and Precedence 15.7.3
int i = 1 / (divisor * loseBig());
} catch (Exception e) {
System.out.println(e);
}
}
static int loseBig() throws Exception {
throw new Exception("Shuffle off to Buffalo!");
}
}
always prints:
java.lang.Exception: Shuffle off to Buffalo!
and not:
java.lang.ArithmeticException: / by zero
since no part of the division operation, including signaling of a divide-by-zero
exception, may appear to occur before the invocation of loseBig completes, even
though the implementation may be able to detect or infer that the division operation
would certainly result in a divide-by-zero exception.
15.7.3 Evaluation Respects Parentheses and Precedence
Java programming language implementations must respect the order of evaluation
as indicated explicitly by parentheses and implicitly by operator precedence. An
implementation may not take advantage of algebraic identities such as the associative
law to rewrite expressions into a more convenient computational order unless
it can be proven that the replacement expression is equivalent in value and in its
observable side effects, even in the presence of multiple threads of execution
(using the thread execution model in §17), for all possible computational values
that might be involved.
In the case of floating-point calculations, this rule applies also for infinity and
not-a-number (NaN) values. For example, !(x=y,
because these expressions have different values if either x or y is NaN or both are
NaN.
Specifically, floating-point calculations that appear to be mathematically associative
are unlikely to be computationally associative. Such computations must
not be naively reordered.
For example, it is not correct for a Java compiler to rewrite 4.0*x*0.5 as
2.0*x; while roundoff happens not to be an issue here, there are large values of x
for which the first expression produces infinity (because of overflow) but the second
expression produces a finite result.
DRAFT
417