How do widening rules apply inside arithmetic expressions (numeric promotion), and what surprises does that cause?

## The core idea: arithmetic forces widening Widening doesn't only happen on assignment -- it also happens **inside expressions**, automatically, via two rules the JLS calls **numeric promotion**. Understanding these explains a whole family of beginner surprises. ## Rule 1: Unary numeric promotion Any single operand whose type is **smaller than int** (`byte`, `short`, `char`) is widened to **int** before use. This applies to operands of `+ - * /`, the unary `-`, array indices, shift counts, etc. There is no byte arithmetic; the smallest arithmetic type is `int`. ## Rule 2: Binary numeric promotion When a binary operator (like `+`) has two numeric operands, the compiler promotes **both** to a common type using this ladder (highest wins, with a floor of int): 1. If either operand is `double` -> both become `double`. 2. Else if either is `float` -> both become `float`. 3. Else if either is `long` -> both become `long`. 4. Otherwise -> both become `int` (this is where byte/short/char land). The **result type of the expression** is that common type. ## Surprise 1: byte + byte is an int ```java byte b1 = 10, b2 = 20; byte sum = b1 + b2; // COMPILE ERROR ``` Both bytes are promoted to int, so `b1 + b2` is an `int`. Assigning an int to a byte is narrowing and needs a cast: `byte sum = (byte)(b1 + b2);`. ## Surprise 2: compound assignment hides a cast ```java byte b = 10; b += 5; // compiles! equivalent to b = (byte)(b + 5) b *= 1000; // compiles, but silently overflows/wraps ``` The JLS defines `E1 op= E2` as `E1 = (T)(E1 op E2)` where T is E1's type -- an **implicit narrowing cast is inserted for you**. Convenient, but it can silently lose data. ## Surprise 3: char arithmetic is int arithmetic ```java char a = 'a'; // code point 97 int x = 'a' + 'b'; // 97 + 98 = 195 (an int), not "ab" char next = (char)(a+1); // 'b' -- must cast back to char ``` String concatenation only happens when one operand is a `String`; with two chars you get integer addition. ## Surprise 4: integer division happens first ```java double half = 1 / 2; // 0.0, not 0.5 double ok = 1.0 / 2; // 0.5 (one operand is double -> double division) ``` Promotion is decided by the operand types **at the operator**, before the assignment. `1` and `2` are both int, so `1/2` is integer division (=0); the widening to double happens only afterward, on the already-truncated 0. ## Surprise 5: overflow stays in the promoted type ```java int a = 100000, b = 100000; long product = a * b; // 1410065408, NOT 10000000000 ``` Both operands are int, so the multiply is int arithmetic and overflows (wraps) before being widened to long. Fix: make an operand long first: `long product = (long) a * b;`. ## Mental checklist - Anything smaller than int -> promoted to int in arithmetic. - Mixed types -> result is the widest operand (min int). - Decide promotion at the operator, not the assignment target. - Compound assignment silently re-narrows. - To avoid overflow, widen an operand *before* the operation.