Java Primitive Types and Expression Evaluation

Primitive Values and Variables

Java programs store values in variables and combine values in expressions. A primitive type is a basic Java type whose values are handled directly by the language. The three central AP Computer Science A types are int, double, and boolean.

• int stores whole-number values.

• double stores decimal or floating-point values.

• boolean stores either true or false.

A variable has a declared type, a name, and optionally an initial value. For example, int students = 28; declares an int variable, while boolean schoolOpen = true; declares a boolean variable. The value stored in a variable may change during execution, but its declared type does not change.

A literal is a fixed value written directly in Java source code, such as 12, 4.99, or false. An integer literal can be assigned to a double because Java can perform a widening conversion: double value = 6; stores the value 6.0. The reverse direction is not automatically safe because a double may contain a fractional part.

Takeaway: Identify the declared type of every variable and the type of each literal or subexpression assigned to it.

Operators and Evaluation Order

Java's arithmetic operators are +, -, *, /, and %. The unary operators + and - can indicate a number's sign. The result of an expression depends on both the operators and the types of its operands.

Operator precedence determines evaluation order. Java evaluates parentheses first, then multiplication, division, and remainder, and finally addition and subtraction. Operators at the same precedence level are evaluated from left to right. Thus, 2 + 3 * 4 produces 14, whereas (2 + 3) * 4 produces 20. The expression 20 / 5 * 2 is evaluated from left to right and produces 8.

The + operator also performs concatenation when either operand is a String. Evaluation still proceeds from left to right. Therefore, "Total: " + 2 + 3 produces "Total: 23", while "Total: " + (2 + 3) produces "Total: 5".

Use parentheses whenever they clarify the intended grouping, particularly when arithmetic is combined with string concatenation.

Takeaway: Trace an expression in precedence order, and remember that a String changes the behavior of + from addition to concatenation.

Integer Arithmetic and Remainders

When both operands are int values, Java performs integer division for /. The fractional part is discarded by rounding toward zero: 7 / 3 produces 2, 10 / 4 produces 2, and -7 / 3 produces -2. Assigning the result to a double afterward does not restore the discarded fraction, so double value = 7 / 3; stores 2.0.

To preserve the fraction, at least one operand must be a double. For example, 7.0 / 3 produces an approximate decimal result. A cast before division also works: (double) 7 / 3. However, (double) (7 / 3) is too late because integer division has already produced 2.

The remainder operator % gives the remainder after division. For example, 17 % 5 produces 2. A common divisibility test is number % 2 == 0, which is true when number is even. With integer operands, the remainder keeps the sign of the dividend, so -5 % 3 produces -2.

An integer division or remainder operation with a zero divisor causes an ArithmeticException at run time. Integer calculations can also exceed the fixed range of int. This integer overflow does not automatically create a larger value; adding one to 2_147_483_647 produces the wrapped value -2_147_483_648.

Takeaway: Before evaluating / or %, check the operand types and confirm that a divisor is not zero.

Floating-Point Behavior

A double uses floating-point representation. Floating-point arithmetic supports fractional values and a large range of magnitudes, but some decimal values cannot be represented exactly in binary. As a result, an expression such as 0.1 + 0.2 may produce a value commonly displayed as 0.30000000000000004 rather than an exact 0.3.

When comparing calculated double values, use a tolerance when appropriate. Compute the absolute difference with Math.abs(actual - expected) and check whether it is less than a small threshold such as 0.000001. This tests whether the values are sufficiently close instead of requiring exact binary equality.

Floating-point division by zero behaves differently from integer division. It can produce special values such as positive infinity, negative infinity, or NaN, rather than throwing the integer division exception.

Takeaway: Use int for exact whole-number calculations within range, and treat calculated double values as potentially approximate.

Casting and Numeric Conversion

Casting explicitly converts an expression by using the form (targetType) expression. Casting a double to an int discards the decimal portion and moves toward zero: (int) 7.9 produces 7, and (int) -7.9 produces -7. A cast does not round to the nearest integer.

Use Math.round when rounding is intended. Math.round(6.7) produces 7 as a long, whereas (int) 6.7 produces 6. The two operations have different purposes.

A conversion from int to double is a widening conversion. A conversion from double to int is a narrowing conversion because information may be lost, so Java requires an explicit cast. Numeric promotion also occurs inside expressions: when an arithmetic operation includes a double, an int operand is generally promoted to double before that operation.

The location of a cast matters. With int x = 7; and int y = 3;, x / y produces 2, but (double) x / y produces an approximate value of $2.3333$. By contrast, (double) (x / y) produces 2.0 because the integer division happens first.

Takeaway: Cast an operand before division to preserve a fractional result, and use Math.round rather than casting when the goal is rounding.

The Math Class

The Math class supplies static methods for common calculations. Call these methods with the class name, such as Math.sqrt(25.0), which produces 5.0. Common methods include:

• Math.abs(x) for absolute value.

• Math.pow(a, b) for raising one value to a power; its result is a double.

• Math.sqrt(x) for a square root.

• Math.max(a, b) and Math.min(a, b) for the larger or smaller value.

• Math.round(x) for rounding a floating-point value to an integral result.

• Math.random() for a pseudorandom double from $0.0$ inclusive to $1.0$ exclusive.

For a square, multiplication such as side * side is often clearer than Math.pow(side, 2). A distance calculation can use Math.sqrt and Math.pow with horizontal and vertical differences as the two squared components.

To generate an integer from 0 through 9, use (int) (Math.random() * 10). More generally, an integer from lower through upper, inclusive, can be generated with (int) (Math.random() * (upper - lower + 1)) + lower. For a six-sided die, (int) (Math.random() * 6) + 1 gives a value from 1 through 6.

Takeaway: Check the return type and interval of each Math method, especially when converting a random double into an integer range.

Tracing Types and Values

When tracing Java code, determine both the type and the value of each important subexpression. Consider int a = 9;, int b = 4;, and double result = a / b + 0.5;.

1. a / b uses two int operands, so integer division produces 2.

2. The expression 2 + 0.5 includes a double, so the addition produces 2.5.

3. The final variable stores 2.5.

The result is not 2.75, because the fractional part was discarded before 0.5 was added. To obtain the decimal quotient, use double result = (double) a / b + 0.5;. The cast changes the division itself, so the quotient is approximately $2.25$, and the final result is $2.75$.

A reliable tracing process is:

1. Record each variable's declared type and current value.

2. Apply parentheses and operator precedence.

3. Determine whether each arithmetic operation is integer or floating-point arithmetic.

4. Apply casts and numeric promotion at the point where they occur.

5. Continue until the final assignment or output is reached.

Takeaway: Do not infer the final type or value from the assignment alone; trace every operation in order.