Unit 1 — Using Objects & Methods

Casting & Type Conversion New in 2026

Casting is one of the most-tested Unit 1 topics on the AP CSA exam. Questions on integer division, truncation, and forced floating-point division appear in nearly every exam. The 2025-2026 curriculum gives casting explicit treatment in section 1.5.

The Integer Division Trap

When both operands of / are int, Java performs integer division — the result is truncated to an integer. This is not a bug; it is designed behavior.

int a = 7;
int b = 2;
System.out.println(a / b);      // prints 3, not 3.5
System.out.println(7 / 2);      // prints 3
System.out.println(7.0 / 2);    // prints 3.5
System.out.println((double)7 / 2); // prints 3.5

Explicit Casting Syntax

double x = 9.7;
int n = (int) x;        // n = 9 (truncated, not rounded)

int p = 5;
int q = 2;
double result = (double) p / q;  // 2.5 — cast p FIRST, then divide
double wrong  = (double)(p / q); // 2.0 — divides first, then casts result

Truncation vs Rounding

Casting double to int truncates (drops the decimal), it does NOT round. This applies to both positive and negative values.

Expression	Result	Explanation
(int) 3.9	3	Drops .9 — NOT rounded to 4
(int) 3.1	3	Drops .1
(int) -2.9	-2	Truncates toward zero, NOT -3
(int) -2.1	-2	Truncates toward zero
(int)(3.9 + 0.5)	4	Add 0.5 before casting to round

Widening vs Narrowing Conversion

Widening (automatic — no cast needed)

Widening moves to a type that can hold all values of the original. No data is lost, so Java does it automatically.

int n = 42;
double d = n;     // widening: int automatically becomes double (42.0)
long L = n;       // widening: int to long (also automatic)

Narrowing (requires explicit cast)

Narrowing moves to a smaller type. Data may be lost, so Java requires an explicit cast to show you’re aware.

double d = 9.99;
int n = (int) d;  // narrowing: requires explicit cast, n = 9

double pi = 3.14159;
int truncated = (int) pi;   // truncated = 3

Casting with Math.random()

The standard pattern for generating a random integer in a range combines Math.random() (which returns a double in [0.0, 1.0)) with casting and scaling.

// Random int from 0 to 9 inclusive
int n = (int)(Math.random() * 10);

// Random int from 1 to 6 inclusive (die roll)
int die = (int)(Math.random() * 6) + 1;

// Random int from min to max inclusive
int rand = (int)(Math.random() * (max - min + 1)) + min;

Overflow and Integer Range

An int holds values from -2,147,483,648 to 2,147,483,647. If arithmetic produces a value outside this range, it wraps around without error. This is called integer overflow.

int max = Integer.MAX_VALUE;   // 2147483647
System.out.println(max + 1);  // -2147483648 (overflow! wraps to MIN_VALUE)

Practice MCQs

Common Mistakes

• Integer division in averages: sum / count when both are int truncates. Cast first: (double) sum / count.
• Casting after division: (double)(sum/count) casts the truncated integer, not the true average.
• Thinking truncation rounds: (int)3.9 is 3, not 4. Add 0.5 before casting to round.
• Casting Math.random() too early: (int)Math.random() * N casts Math.random() first (always 0). Always wrap the full product: (int)(Math.random() * N).
• Confusion with negative truncation: (int)(-2.9) = -2, not -3. Truncation is toward zero.

Related Topics