AP CSA Unit 1 Notes: Building Programs with Variables, Types, and Expressions in Java

Programming

The process of writing precise, step-by-step instructions that a computer can follow to solve problems.

Strong typing

A language feature (like in Java) that requires variables to have explicit data types, reducing ambiguity about what values can be stored and used.

Java Virtual Machine (JVM)

The system that runs Java bytecode, helping Java programs behave consistently across different computers.

Variable

A named storage location in memory that holds a value which can be used, updated, and combined with other values.

Primitive type

A built-in basic data type that stores a simple value directly (e.g., int, double, boolean, char).

Reference type

A type whose variables store a reference to an object rather than the entire value directly (e.g., String).

Declaration

A statement that creates a variable by specifying its type and name (e.g., int score;).

Initialization

Assigning a variable its first value (often done at the same time as declaration).

Constant (final)

A variable marked with final whose value should not change after initialization (often written in ALLCAPSWITH_UNDERSCORES).

int

A primitive type that stores whole numbers (negative, zero, or positive); commonly used for counting and indexing.

double

A primitive type that stores decimal numbers as floating-point approximations (not all decimals are stored exactly).

boolean

A primitive type that stores one of two values: true or false; used for logical results and conditions.

char

A primitive type that stores a single Unicode character written in single quotes (e.g., 'A'); not the same as String.

Expression

Code that produces a value (such as a number, boolean, or character), e.g., 4 + 5 or count > 10.

Assignment statement

A statement that stores the value of the right-hand expression into the left-hand variable using = (e.g., x = x + 3;).

Operator precedence

Rules that determine the order operations are evaluated (e.g., *, /, % before +, -; parentheses override).

Integer division

Division where both operands are integers, causing the decimal part to be discarded (truncated toward zero), e.g., 7/2 becomes 3.

Modulus operator (%)

An operator that returns the remainder after division (e.g., 27 % 10 is 7); often used for even/odd checks and last digits.

String concatenation

Using + to join strings; if either operand is a String, Java converts the other to a string and combines them, evaluated left to right.

Overflow

When a calculation exceeds a numeric type’s range; for Java integers, the value wraps around rather than producing an error.

Casting

Converting a value from one type to another (e.g., (int) 19.99 becomes 19), which can lose information.

Widening conversion (implicit cast)

An automatic conversion from a narrower type to a wider type (e.g., int to double), often occurring in mixed-type arithmetic.

Narrowing conversion (explicit cast)

A conversion from a wider type to a narrower type that requires a cast (e.g., double to int) and may drop decimals or cause wraparound.

Compound assignment operator

A shortened update form like +=, -=, *=, /=, %= that combines an operation with assignment; can include an implicit cast to the left variable’s type.

Prefix vs. postfix increment

With ++ in an expression: postfix (x++) evaluates to the old value then increments; prefix (++x) increments first then evaluates to the new value.