What is a variable, and why do we need types?

A program that just prints “Hello, World” isn’t very useful. Real programs work with data, test scores, prices, names, true/false flags, and that data has to live somewhere while the program runs. That somewhere is a variable: a named storage location that holds a value, where the value can change as the program executes.

Naming a storage location is only half the picture. Java is a statically typed language, which means every variable also has a fixed data type that the compiler tracks. The data type tells Java two things: what set of values can be stored there, and what operations are allowed on those values. Storing the number 42 behaves very differently from storing the text "42", one is an integer you can do arithmetic on, the other is a string of characters.

The two categories: primitive vs. reference

Java divides every data type into one of two categories. Primitive types directly hold simple values like numbers and Boolean truth values. Reference types are used to define objects, things like String, Scanner, and any class you write yourself. The CED is explicit about this distinction because it’s the foundation for everything you’ll learn about objects in Unit 1, classes in Unit 3, and collections in Unit 4.

For now, the important thing is that primitives hold the value itself, while references hold a way to find an object that lives elsewhere in memory. In Lesson 1.2 we work entirely with primitives. Reference types come in lesson 1.5 when you create your first String object.

The three primitive types in AP CSA

Each of the three has a specific job, defined by what values it can hold:

• int. Stores an integer (a whole number, positive, negative, or zero). Examples: 0, 42, -7, 1000000. The int type cannot store decimals.
• double. Stores a real number, including decimals. Examples: 3.14, -0.5, 2.0, 99.99. Use double any time the value has a fractional part or could need one.
• boolean. Stores exactly one of two values: true or false. No quotes, no capitals. Use boolean for yes/no flags, on/off states, and the result of comparisons.

Declaring variables: the syntax

To declare a variable in Java, you write the data type, then the variable name, optionally followed by = and an initial value, and finally a semicolon. The pattern is:

dataType variableName = initialValue;

Concrete examples that follow the AP CSA scope:

int score = 0;
double price = 19.99;
boolean isPassing = true;

You can also declare a variable without giving it an initial value, int score; is legal, but the variable then has no usable value, and Java will refuse to let you use it in an expression until you assign one. This is called definite assignment, and on the AP exam any code that reads from an uninitialized local variable is a syntax/compile error.

Variable naming rules

Java imposes a small set of rules for variable names. They are not optional, breaking them produces a syntax error and the compiler refuses to compile the program:

• Must start with a letter, an underscore (_), or a dollar sign ($), never a digit.
• After the first character, can contain letters, digits, underscores, and dollar signs.
• Cannot be a Java reserved word (int, double, boolean, class, if, etc.).
• Case sensitive: score and Score are two different variables.
• Convention (not a rule, but expected on the exam): use camelCase. The first word is lowercase; subsequent words start with a capital letter. So numStudents, not num_students or NumStudents.

Key vocabulary

double bookId = 4271.0;
int lateFee = 2.50;
boolean isCheckedOut = "true";

Common AP exam traps

The exam tests these same mistakes year after year. Spotting them in May starts with recognizing them now.

Deep dive: more on this topic