Primitives are Java's built-in basic data types that store simple values directly in memory. On AP CSA you work with three of them: int (whole numbers), double (decimals), and boolean (true/false). Unlike objects, primitives have no methods and you never call new to create them.
Primitives are the simplest kind of data in Java. A primitive variable holds the actual value itself, a number like 42 or 3.14, or the value true or false. That's it. There's no object wrapped around it, no methods to call, no dot notation. You can't write 5.toString() because 5 isn't an object.
Full Java has eight primitive types, but the AP CSA exam only tests three: int for integers, double for decimal (floating-point) numbers, and boolean for true/false values. Everything else you work with in the course, including String, arrays, and ArrayList, is a reference type, meaning the variable stores a memory address pointing to an object rather than the value itself. That one distinction (value vs. reference) explains a huge amount of Java behavior, from why == works on ints but not Strings to why int division throws away the decimal.
Primitives are so foundational that the College Board named Unit 1 after them (Primitive Types). The unit covers declaring and initializing int, double, and boolean variables, evaluating arithmetic expressions, and casting between types. But the payoff never stops. Every later unit assumes you know how primitives behave. Loop counters in Unit 4 are ints. Conditions in Unit 3 evaluate to booleans. Array traversals, averages in 2D array FRQs, and accumulator patterns all depend on you knowing that 7 / 2 is 3 (not 3.5) and that comparing primitives with == is fine while comparing objects with == is usually a bug. If you're shaky on primitives, errors will follow you through all ten units.
Variable (Unit 1)
A variable is a named container, and its declared type decides what fits inside. Declaring int x means x can only ever hold whole numbers. Primitive variables hold the value itself, while object variables hold a reference, which is why copying an int copies the number but copying an ArrayList copies the address.
Typecasting (Unit 1)
Casting converts between primitive types. Java widens int to double automatically, but going the other way requires an explicit cast like (int) 3.9, which truncates to 3 (it does not round). The classic exam trick is fixing integer division by casting first, since (double) 7 / 2 gives 3.5 but (double) (7 / 2) gives 3.0.
Arithmetic Operators (Unit 1)
How +, -, *, /, and % behave depends entirely on the primitive types involved. Two ints divided give an int with the decimal chopped off, and mixing an int with a double promotes the result to double. The modulo operator % only makes intuitive sense once you understand int arithmetic.
Import Statement (Unit 1)
A nice contrast that clarifies what primitives are. Classes like Scanner or ArrayList live in packages and may need importing, but primitives are baked into the Java language itself. You never import int, double, or boolean.
Primitives are everywhere on the exam even when the question isn't 'about' them. MCQs love expression-evaluation traps: integer division (5 / 2 is 2), mixed int/double arithmetic, truncation from casting, and modulo results. You'll also see questions where choosing the wrong return type or comparison breaks the logic. On FRQs, you're expected to pick the right primitive type without being told: int for counters and indices, double for averages and prices, boolean for flags and return values of methods like isValid. A super common FRQ point-loser is computing an average with int division, like sum / count when both are ints, and silently dropping the decimal. Declaring types correctly and handling int vs. double arithmetic is free points if you're careful.
Primitives store the value itself; reference types store a memory address pointing to an object. Practical fallout: primitives have no methods (no dot notation), == compares primitive values directly but compares addresses for objects (use .equals() for Strings), and the default for an unassigned object is null while primitives can never be null. String looks primitive because it has literal syntax, but it's an object.
The AP CSA exam tests exactly three primitive types: int for whole numbers, double for decimals, and boolean for true or false.
Primitives store values directly and have no methods, while reference types like String and ArrayList store addresses pointing to objects.
Dividing two ints gives an int and throws away the decimal, so 7 / 2 equals 3, not 3.5.
Casting a double to an int truncates toward zero, so (int) 3.9 is 3, and casting one operand to double before dividing is the standard fix for integer division.
Use == to compare primitives, but use .equals() to compare objects like Strings, because == on objects compares references, not contents.
String is not a primitive, even though it has literal syntax like "hello"; it's a class, which is why it has methods like .length() and .substring().
Primitives are Java's basic built-in data types that store values directly rather than as objects. The AP CSA exam covers three: int (whole numbers), double (decimals), and boolean (true/false), all introduced in Unit 1.
No. String is a class, which makes it a reference type. That's why Strings have methods like .length() and why you compare them with .equals() instead of ==. The literal syntax ("hello") makes it look primitive, but it isn't.
A primitive variable holds the actual value (like 42), while an object variable holds a reference to where the object lives in memory. Primitives have no methods and can never be null; objects have methods and can be null.
Because both operands are ints, Java performs integer division and truncates the decimal. To get 3.5, make at least one operand a double, for example (double) 7 / 2 or 7 / 2.0. This trap shows up constantly on MCQs and average-computing FRQs.
No. Java has eight primitives (including byte, short, long, float, and char), but the AP CSA course subset only tests int, double, and boolean. Knowing those three deeply matters far more than memorizing the rest.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.