تحويل الأنواع والتحويل القسري (casting)

Written Explanation

Widening: small box to bigger box

A widening conversion goes from a type to one that can hold at least the same range of values. The compiler performs it automatically, with no extra syntax:

byte -> short -> int -> long -> float -> double       char -> int

int whole = 7;
double wide = whole;    // 7 becomes 7.0, automatically

Widening between integer types is exact. Widening an int to a double is also exact. The Language Specification warns about one subtle case: converting an int or long to float, or a long to double, can lose some of the least significant digits, because a float has only about seven significant decimal digits of precision. So "widening" means "bigger range", not always "perfect copy". Example 3 shows it.

Narrowing: big box to smaller box

A narrowing conversion goes the other way, for example double to int, long to int, or int to byte. Java does not do these automatically, because information may be lost. If you try, the compiler stops you:

error: incompatible types: possible lossy conversion from double to int

If you really mean it, you write a cast: the target type in parentheses before the value.

double pi = 3.99;
int cut = (int) pi;     // 3

The cast says "I know this may lose information, and I accept that". Two rules of what happens:

• Decimal to whole number: the fraction is cut off, not rounded. (int) 3.99 is 3, and (int) -3.99 is -3: the result moves toward zero. If you want rounding, the standard method Math.round(x) rounds to the nearest whole number (it returns a long).
• Whole number to a smaller whole type: only the low bits are kept. The value can change completely, including its sign. For example (byte) 130 is -126.

Integer division

When both operands of / are integers, the result is an integer: the fraction is dropped. So 7 / 2 is 3, not 3.5. The remainder operator % gives what is left over: 7 % 2 is 1.

If either operand is a double, the other is widened and the division is a decimal one: 7 / 2.0 is 3.5.

Where you put the cast matters:

A frequent beginner bug is double share = total / people; with two ints. The division is done in integers, then the result is widened to double. The decimals were already lost.

Integer overflow

Every whole-number type has a maximum. What happens when you go past it? Java does not raise an error. The result wraps around: it keeps only what fits, as if an odometer rolled past its largest number.

int max = Integer.MAX_VALUE;   // 2147483647
System.out.println(max + 1);   // -2147483648

The Language Specification says integer operators never signal overflow; results wrap, keeping the low-order bits. Adding 1 to the largest int gives the smallest. This is why overflow is a silent bug: the program continues with a wrong, often negative, number.

Overflow also hides in multiplication. 1_000_000 * 1_000_000 is a trillion, which is far outside int. Because both operands are int, Java does the whole multiplication as int and wraps. Assigning the result to a long variable afterwards does not help, because the damage is done before the assignment. The fix is to make one operand long first:

long ok = (long) a * a;    // a is widened to long, so the multiplication is done as long

When arithmetic mixes types, Java first widens both operands to a common type (int with long gives long; anything with double gives double), then calculates in that type.

Seeing overflow instead of hiding it

If wrapping would be a bug, the standard library provides Math.addExact(a, b) and similar methods that throw an ArithmeticException (message integer overflow) instead of wrapping. Using them is a later-module topic; it is enough to know they exist.