Rycal · rycal.web.app · AP Computer Science A · Unit 1 of 10

Unit 1: Primitive Types

Unit 1 is where Java begins. It covers declaring variables, the three primitive types you will rely on all year, and doing arithmetic the way Java does it. The rules are few but exact, and the exam tests them constantly, especially integer division and casting.

AP Computer Science APrimitive TypesAbout 12 minutes to read

How to use this guide

Read it in order the first time because the topics build on each other. Variables give you the types, expressions do arithmetic with those types, compound operators abbreviate the assignments, and casting converts between types. Exam questions usually show a short snippet and ask for its value or its output, so trace each example with a pencil as you read.

After the first read, use the trap boxes and the tables to review the distinctions that exam questions test most often. Finish with the practice questions, then complete the recall check on the last page out loud and note any items you cannot explain yet.

What this unit is worth. Unit 1 is about 2.5 to 5 percent of the AP CSA exam, but its concepts (especially integer division and casting) appear in questions across every other unit. Getting these mechanics automatic pays off everywhere.

1.1 Why Programming? Why Java?

A program is a set of instructions a computer follows to do something useful. Java is a general-purpose programming language, and it is the language of the AP CSA exam. Everything in this course, from Unit 1 through Unit 10, is written in Java.

Java is a compiled language. You write source code in a text file, and a compiler translates it into bytecode, a lower-level form the computer can run. That bytecode runs on the Java Virtual Machine (JVM), which exists on many kinds of computers. Because programs run on the JVM instead of directly on one machine's hardware, the same Java program runs in different places without being rewritten. This section is background. The exam tests the Java you write, not the story of the language.

1.2 Variables and Data Types

A variable is a named storage location that holds one value. Every variable has a type, which decides what kind of value it can hold. Unit 1 uses three primitive types, the simple built-in types Java provides.

Type	Holds	Example
`int`	Whole numbers: positive, negative, or zero	`int count = 12;`
`double`	Numbers with decimal points	`double price = 4.99;`
`boolean`	The values `true` or `false` only	`boolean done = false;`

Declaring a variable announces its name and type. Initializing it gives it a first value. You can do both in one line or in two steps.

int total;              // declared
total = 0;              // initialized
int sum = total + 5;    // declared and initialized at once

Trap. Using a local variable before it has been given a value is a compile error. Java does not fill in a starting value for you. The line int x; System.out.println(x); will not compile, because x was declared but never initialized.

1.3 Expressions and Assignment Statements

An expression is anything that produces a value: a literal like 7, a variable like count, or values and variables combined with operators like count + 3. An assignment statement stores a value in a variable with a single =. The right side is evaluated first, and the result is stored in the variable on the left. The = means "store," not "equals."

Java follows the order of operations you know from math, with one addition. Multiplication, division, and the remainder operator % run before addition and subtraction. Operators at the same level run left to right. Parentheses override everything.

int a = 2 + 3 * 4;      // 14, not 20
int b = 10 - 4 / 2;     // 8, not 3
int c = (10 - 4) / 2;   // 3
int d = 20 / 4 * 2;     // 10: left to right, 5 * 2

When an expression mixes int and double, the int values are converted and the result is a double. When both operands are int, the result is an int, even when the true quotient has a fractional part. This is integer division: 7 / 2 is 3, not 3.5, and 1 / 2 is 0, not 0.5. The remainder is discarded, never rounded.

double x = 7 + 2.0;   // 9.0: one double operand makes it double
int y = 7 / 2;        // 3: both int, so the .5 is discarded

Trap. Integer division is the most tested idea in Unit 1. Before you compute any division, check the operand types. If both are int, the answer is an int with the fraction thrown away. Students lose points by reading 7 / 2 as 3.5.

1.4 Compound Assignment Operators

A compound assignment operator does arithmetic on a variable and stores the result back in it, in one step. Each one is shorthand for the longer assignment.

int n = 10;
n += 5;   // 15, same as n = n + 5
n -= 3;   // 12, same as n = n - 3
n *= 2;   // 24, same as n = n * 2
n /= 4;   // 6,  same as n = n / 4
n %= 4;   // 2,  same as n = n % 4

The type rules do not change just because the statement is shorter. In the example above, n /= 4 still does integer division, so 24 / 4 gives the int 6. And n %= 4 stores the remainder 2. The operator += is also the standard way to add one: n += 1 increments n.

Trap. Compound assignment keeps the variable's type for you, silently. For an int n, the statement n += 2.5; compiles and stores 7, because Java inserts the cast to int itself. The plain version n = n + 2.5; is a compile error, since a double result cannot be stored in an int without a cast. The shorthand is not always a safe rewrite of the long form.

1.5 Casting and Ranges of Variables

Casting converts a value from one type to another. Write the target type in parentheses in front of the value. A cast from double to int truncates toward zero: it chops off the decimal part and never rounds. (int) 3.99 is 3, and (int) -3.99 is -3, not -4.

Where you put the cast decides where the conversion happens, and that changes the answer.

int a = 9;
int b = 4;
double x = (double) a / b;     // 2.25: a becomes 9.0 first
double y = (double) (a / b);   // 2.0: integer division runs first

In the first line the cast turns a into 9.0 before the division, so the division is double division. In the second line the parentheses force a / b to run first as integer division (9 / 4 = 2), and the cast only converts the already truncated 2 into 2.0.

Trap. The type of the variable on the left cannot reach back and change how the right side was computed. In double c = 5 / 3;, the division runs first with two ints, giving 1, and c stores 1.0, not 1.666.... If you want the decimal result, cast before dividing: (double) 5 / 3.

Ranges of Variables and Overflow

Every type has a range. An int holds whole numbers from -2,147,483,648 to 2,147,483,647. A double holds a far wider range, including fractional values. If an int calculation passes its maximum, Java does not throw an error. The value wraps around to the negative end, silently. After int big = 2147483647; big = big + 1;, big holds -2147483648.

The exam tests the concept, not the exact boundary numbers: arithmetic that overflows an int wraps instead of failing. One more boundary to know: boolean values cannot be cast to numbers, and numbers cannot be cast to boolean. The line (int) true is a compile error.

Confusions That Cost Points

Pair	How to keep them straight
`7 / 2` vs `7 / 2.0`	Two ints give the int 3, with the remainder discarded. One double operand gives 3.5. Read the operand types before you divide.
`(double) a / b` vs `(double)(a / b)`	The cast converts only what it touches. Cast an operand to get double division. Wrapping the whole integer division converts the already truncated result.
`(int) 3.99` vs rounding	Casts truncate toward zero. `(int) 3.99` is 3 and `(int) -3.99` is -3. A cast never rounds.
`%` is the remainder	`7 % 2` is 1, the leftover after division, not the quotient 3. With negatives the sign follows the left operand: `-7 % 3` is -1.
Declared vs initialized	`int x;` announces `x` but gives it no value. Using `x` before storing something in it is a compile error.
`n += 2.5` vs `n = n + 2.5`	For an `int n`, the compound form compiles and truncates to 7. The plain form is a compile error. Compound assignment keeps the variable's type for you.
`int` overflow	Past 2,147,483,647 an `int` wraps to the negative end instead of erroring. No warning, no exception.

Practice Questions

Original questions written for this guide in the style of the AP exam. Answers and explanations are on the next page, so complete the questions before checking them.

1. Consider the following code segment.

int x = 7;
int y = 2;
System.out.println(x / y);