How does operator precedence differ from operand evaluation order in Java? Use an expression with side effects to illustrate.

## Two separate questions Given an expression, there are two distinct questions: 1. **Structure:** which operator owns which operands? (`2 + 3 * 4` -> `2 + (3 * 4)`.) This is answered by **precedence** and **associativity**. 2. **Timeline:** in what order do the operands actually get computed (which matters only when they have **side effects** — things like method calls, assignments, or `++`)? This is answered by **evaluation order**. Many developers assume that the higher-precedence operator's operands are computed first. That is wrong. Precedence builds the parse tree; it says nothing about the clock. ## Java's evaluation-order guarantee Java specifies that the operands of a binary operator are evaluated **left operand first, then right operand**, and the left is *fully* evaluated (including all its side effects) before the right begins. Argument lists are evaluated left to right too. Array indexing evaluates the array reference before the index. This is a hard guarantee in the Java Language Specification — unlike C and C++, which leave much of it unspecified. ## Worked example with side effects ```java static int log(int v, String tag) { System.out.println(tag); return v; } int x = log(2, "A") + log(3, "B") * log(4, "C"); ``` - **Precedence** groups it as `log(2,"A") + (log(3,"B") * log(4,"C"))`. So the multiplication node sits below the addition node in the tree. - **Evaluation order** prints `A`, then `B`, then `C` — strict left to right — regardless of the fact that `*` is the higher-precedence (deeper) node. The final value is `2 + (3 * 4) = 14`. So the *value* comes from the grouping (14), but the *order of side effects* comes from left-to-right (A, B, C). ## The classic i = i++ + ++i ```java int i = 1; i = i++ + ++i; // i becomes 4 ``` Left to right: `i++` reads 1 and post-increments i to 2 (its value is 1); then `++i` pre-increments i to 3 (its value is 3); the sum is `1 + 3 = 4`; that 4 is assigned to i (overwriting 3). In C/C++ this is undefined behavior; in Java it is fully defined because evaluation order is pinned. (It is still terrible code — never write it — but it demonstrates the guarantee.) ## Why this matters in practice - Reasoning about expressions that mix method calls with operators (logging order, exception ordering, lazily-built state). - Understanding short-circuit operators: `&&`/`||` add the extra rule that the right operand may be **skipped** entirely, which is an evaluation-order concern layered on top of precedence. - Porting code from C/C++: order-dependent expressions that were UB there are defined in Java, but still fragile. ## Deriving the answer Ask two questions separately: 'How does it group?' (precedence/associativity) and 'In what order do side effects fire?' (always left to right in Java). Keep them apart and the trickiest expressions become mechanical.