APCSA 1.5 — Casting and Range of Variables

1) What is Casting?

Casting is converting a value from one data type to another.

Type	Size (bits)	Typical Range / Example	Notes
byte	8	−128 to 127	Smallest integer
short	16	−32,768 to 32,767	Rarely used
int	32	≈ −2.1B to 2.1B	Default integer
long	64	Very large integers	Use `L` suffix
float	32	e.g., `3.14f`	Use `f` suffix
double	64	e.g., `3.14159`	Default decimal
char	16	Single UTF-16 unit	Characters
boolean	—	`true` / `false`	Logical values

2) Widening Conversion (Automatic)

Moving a smaller type into a larger one is safe and automatic.

// int → double (automatic)
int score = 95;
double grade = score;   // 95.0 (no data lost)

Why it’s safe: The larger type can represent every value of the smaller type.

3) Narrowing Conversion (Manual)

Moving a larger type into a smaller one can lose data. You must cast explicitly.

// double → int (manual, truncates)
double pi = 3.14159;
int whole = (int) pi;   // 3 (fraction dropped, not rounded)

Heads-up: Casting from floating-point to integer truncates—no rounding.

4) Type Mismatch Errors

int x = 3.5;      // ❌ compile error: cannot convert double to int
int y = (int) 3.5; // ✅ y becomes 3

5) Range of Variables (Overflow & Underflow)

Each primitive type has a fixed range. Exceeding it wraps around.

byte b = 127;
b++;                     // wraps to −128
System.out.println(b);   // prints -128

Overflow/Underflow: Exceeding the max (or min) value rolls the value around within the fixed bit width.

6) Real-World Division Example

Integer division discards the remainder. Cast to get a precise decimal result.

int totalSeconds = 10000;

// Wrong: int / int → int (2), then widened to 2.0
double hoursWrong = totalSeconds / 3600;

// Right: promote to double before dividing
double hoursRight = (double) totalSeconds / 3600;
// 2.777...

Key Takeaways

Widening (small → large) is automatic.
Narrowing (large → small) requires an explicit (type) cast.
Casting double → int truncates decimals (no rounding).
Choosing too small a type risks overflow/underflow.
Use casting to ensure correct arithmetic (e.g., before division).