Type Conversion, Promotion, Casting

Narrowing integers keeps low bits

300 as a 32-bit int ends with these bits:

0010_1100 is 44 as a signed byte, so (byte) 300 is 44.

For (byte) 200, the kept pattern is 1100_1000. Read as an eight-bit signed value, it is 200 - 256 = -56.

System.out.println((byte) 300); // 44
System.out.println((byte) 200); // -56

This is not equivalent to Java’s remainder operator for all values:

System.out.println(200 % 256);  // 200
System.out.println((byte) 200); // -56

The reliable model is: keep the low bits, then interpret them in the destination type.

Floating point to integer has explicit edge rules

For a direct cast to int, Java applies these rules:

public class FloatToInt {
    public static void main(String[] args) {
        System.out.println((int) 16.9);
        System.out.println((int) -16.9);
        System.out.println((int) Double.NaN);
        System.out.println((int) Double.POSITIVE_INFINITY);
    }
}

Output:

16
-16
0
2147483647

A direct cast from floating point to byte, short, or char first follows the int conversion behavior, then narrows that integer to the final width.

Constant-expression narrowing

Java has a compile-time exception to the usual assignment rule. An int constant expression may initialize byte, short, or char when its value is representable.

byte a = 100;
short b = 20_000;
char c = 65;

final int LIMIT = 127;
byte d = LIMIT;

// byte tooLarge = 128; // compile-time error

int runtimeValue = 100;
// byte e = runtimeValue; // compile-time error

LIMIT is a constant variable because it is final, has primitive type, and is initialized with a constant expression. An ordinary variable does not qualify.

This special assignment conversion does not make an integer literal fit a method parameter:

static void accept(byte value) {}

// accept(1);       // compile-time error
accept((byte) 1);   // valid

Unary and binary numeric promotion

Most arithmetic does not operate in byte, short, or char. Unary numeric promotion converts them to int for operators such as unary +, unary -, and bitwise ~.

Binary numeric promotion chooses a common type for operators such as +, -, *, /, %, and numeric comparisons:

That final rule explains this error:

byte a = 10;
byte b = 20;
// byte sum = a + b;       // a + b has type int
byte sum = (byte) (a + b);

The parentheses matter. (byte) a + b casts only a, which is promoted back to int before addition. Casting (a + b) narrows the result.

Compile-time constants create a useful contrast:

byte oneHundred = 50 * 2;  // constant expression, value fits

byte fifty = 50;
// byte result = fifty * 2; // runtime expression has type int

Compound assignment includes a conversion

These statements are not equivalent at compile time:

byte count = 127;
// count = count + 1; // error: int cannot be assigned to byte
count += 1;           // valid, equivalent to a cast back to byte
System.out.println(count); // -128

Conceptually, count += 1 behaves like count = (byte) (count + 1). The implicit narrowing can overflow, so compact syntax does not remove the risk.

Integer division happens before assignment

int total = 7;
int count = 2;

double wrong = total / count;
double stillWrong = (double) (total / count);
double correct = (double) total / count;

The assignment target does not change how the right side was evaluated. Convert an operand before division when a fractional result is required.

Widening can round

int exact = 16_777_216;
int next = 16_777_217;

float first = exact;
float second = next;

System.out.println((long) first);
System.out.println((long) second);
System.out.println(first == second);

Output:

16777216
16777216
true

A float has 24 bits of binary precision, including its implied leading bit. 2^24 + 1 needs another precision bit, so it rounds. The conversion is widening in the Java language because no cast is required, but it is not value-preserving for every int.