Type casting and numeric promotion

For this lesson, we'll focus on primitive conversions: which ones are automatic, what narrowing does to your bits, and the promotion rules that decide the type of every arithmetic expression. Interviewers lean on this topic for "what does this print?" questions, because three lines of arithmetic can hide an overflow, a truncation and a compile error.

01Picture it first: the widening graph

Picture a set of one-way streets. You can always drive from a narrower type to a wider one without a ticket (no cast). Driving the other way is allowed, but only if you sign a waiver: the cast, which says "I accept that data may be lost".

Fig. 1

Widening conversions: byte to short to int to long to float to double, char to int; int to float, long to float and long to double may lose precision

Notice two things about the graph:

1. char sits on a side road. It widens to int, but byte → char, short → char and char → short all need casts, because char is unsigned and short is signed: neither range contains the other.
2. "Widening" doesn't mean "lossless". A float has only 24 bits of precision, so (float) 16_777_217 becomes 16777216.0. A double has 53, so a long above 2⁵³ can come back different: (long) (double) 9_007_199_254_740_993L gives 9007199254740992.

02Narrowing: what a cast actually does

System.out.println((int) 3.99);      // ?
System.out.println((int) -3.99);     // ?
System.out.println((int) 1e20);      // ?
System.out.println((int) Double.NaN);// ?
System.out.println((byte) 200);      // ?
System.out.println((byte) 300.7);    // ?
System.out.println((short) 70000);   // ?

3
-3
2147483647
0
-56
44
4464

There are two different rules at work, and mixing them up is where people slip:

• Integer → smaller integer keeps only the low bits. 200 is 1100 1000 in binary; as a byte, the top bit is the sign bit, so you get -56. 70000 keeps its low 16 bits and becomes 4464. Nothing is clamped, the high bits are simply thrown away.
• Floating point → integer truncates toward zero (not floor: -3.99 becomes -3), maps NaN to 0, and clamps values that are too large to MAX_VALUE or MIN_VALUE. When the target is byte, short or char, Java first converts to int with those rules and then keeps the low bits. That's why (byte) 300.7 is (byte) 300, which is 44.

03Binary numeric promotion (JLS §5.6)

Every arithmetic operator (+ - * / %, comparisons, bitwise & | ^ on numbers, and the conditional ?: with numeric operands) first promotes both operands to a common type. The rule is a short ladder, checked top to bottom:

There's also unary promotion: byte, short and char become int for unary -, +, ~, array indices and each operand of a shift. The upshot is that Java never does arithmetic in byte, short or char. The smallest arithmetic type is int.

byte b = b + 1 vs b += 1

byte b = 10;
b = b + 1;      // (1)
b += 1;         // (2)
b++;            // (3)
byte c = 10 + 1;// (4)

Line (1) is a compile error: incompatible types: possible lossy conversion from int to byte. b + 1 is an int, and you can't assign an int expression to a byte without a cast. Lines (2), (3) and (4) compile:

• Compound assignment E1 op= E2 is defined as E1 = (T) (E1 op E2): the cast to E1's type is built in. So b += 1 compiles, and with b = 127 it silently gives -128. The same hidden cast makes int i = 10; i += 3.7; legal, leaving i at 13.
• ++ and -- also include the narrowing cast.
• 10 + 1 is a constant expression. If its value fits in the target type, the compiler narrows it for you. byte c = 128; fails because 128 doesn't fit.

Integer division

When both operands are integers, / is integer division that truncates toward zero, and the type of the variable you assign to doesn't change that.

int sum = 7, count = 2;
double avg = sum / count;          // 3.0: divided as int, then widened
double ok  = (double) sum / count; // 3.5: cast binds tighter than /
double bad = (double) (sum / count); // 3.0: cast applied too late
System.out.println(5 / 2 * 2.0);   // 4.0: 5 / 2 is already 2
System.out.println(2.0 * 5 / 2);   // 5.0: double from the first step

Evaluation is left to right with normal precedence, and promotion happens per operation, not once for the whole line. That's the root of the next bug too.

04Long overflow before widening

long microsPerDay = 24 * 60 * 60 * 1000 * 1000;
System.out.println(microsPerDay);

It prints 500654080. Every literal is an int, so every multiplication is int maths. The true value, 86,400,000,000, overflows int at the last step, wraps, and only then is the wrapped result widened to long. The variable's type comes too late to help.

long microsPerDay = 24L * 60 * 60 * 1000 * 1000;  // 86400000000

Making the first operand a long promotes every following step to long. Putting the L on the last literal happens to work here, because 24 * 60 * 60 * 1000 (86,400,000) still fits in an int, but it's fragile: in 30 * 24 * 60 * 60 * 1000 * 1000L the int part has already overflowed before the long shows up. The habit to build is "widest operand first", or Math.multiplyExact so overflow throws.

05char arithmetic

A char is a 16-bit unsigned number, so it takes part in arithmetic like any integer, after promotion to int.

char c = 'a';
System.out.println(c + 1);          // 98   (int)
System.out.println((char) (c + 1)); // b
c += 1;                             // OK: compound assignment casts back to char
char d = 'a' + 1;                   // OK: constant expression that fits
// char e = c + 1;                  // compile error: int to char
System.out.println('a' + 'b' + "c");// 195c (left to right: int addition first)
System.out.println("c" + 'a' + 'b');// cab  (string concatenation from the start)

The last two lines are a favourite: + is evaluated left to right, and whether it means "add" or "concatenate" depends on whether a String has appeared yet.

06Advanced: edge cases worth knowing

A few more rules that show up in "what does this print?" questions:

• Shift distance is masked. For int, only the low 5 bits of the distance are used, so 1 << 32 is 1, not 0. For long it's 6 bits: 1L << 32 is 4294967296.
• The conditional operator promotes. true ? 1 : 2.0 is the double 1.0, because the two branches undergo binary numeric promotion.
• float literals need f. float f = 1.5; doesn't compile: 1.5 is a double, and double → float is narrowing.
• (float) 0.1 widened back is not 0.1. (double) 0.1f is 0.10000000149011612, which is why 0.1f == 0.1 is false.
• Overflow and precision checks exist. Math.toIntExact, Math.multiplyExact, Math.addExact throw instead of wrapping.

07How to say it in the interview

When I ask about casting, I'm listening for three things: do you know that narrowing drops high bits (and doesn't clamp) for integers, do you know arithmetic happens in at least int, and can you explain why 24 * 60 * 60 * 1000 * 1000 goes wrong instead of just knowing that it does.

Here's how this might look if you sketch it on the whiteboard: