Introduction

In programming, we need ways to store and manipulate information. Variables are the foundation of any program—they hold the data your program works with. Topic 1.2 introduces the concept of variables and the three primitive data types used in AP Computer Science A: int, double, and boolean.

Understanding data types is essential because they determine what kind of values a variable can hold and what operations can be performed on those values. Choosing the correct data type ensures your program works efficiently and produces accurate results.

Data Types in Java

What is a Data Type?

A data type is a set of values and a corresponding set of operations on those values. Every variable in Java must have a declared type that determines what kind of data it can store.

Primitive vs. Reference Types

Data types in Java can be categorized as either primitive or reference types.

Primitive types store simple values directly. They are the basic building blocks of data in Java. AP Computer Science A focuses on three primitive types: int, double, and boolean.

Reference types are used to define objects that are not primitive types. Reference types include classes like String, ArrayList, and any custom classes you create. We'll explore reference types in later topics.

Key Difference:

The Three Primitive Data Types

int (Integer)

An int value is an integer—a whole number with no decimal point. Integers can be positive, negative, or zero.

Valid int values:

42
-17
0
1000000
-999

Invalid int values:

3.14        // Has decimal point (use double)
"25"        // String, not number
2,500       // Cannot use commas

Common uses for int:

Example declarations:

int numberOfStudents;
int temperature;
int score;

double (Floating-Point Number)

A double value is a real number that can include a decimal point. The name "double" refers to "double precision floating-point," which means it can store very large or very small numbers with decimal precision.

Valid double values:

3.14159
-0.5
2.0
1000.25
0.0

Note: Even 2.0 is a double because it has a decimal point, whereas 2 is an int.

Common uses for double:

Example declarations:

double gpa;
double price;
double pi;

Important: Numbers without decimal points are treated as int, even if stored in a double variable. Numbers with decimal points are treated as double.

double x = 5;      // 5 is int, converted to 5.0
double y = 5.0;    // 5.0 is double
int z = 5.0;       // ERROR! Cannot store double in int

boolean (True or False)

A boolean value is either true or false. Boolean values are used for decision-making and controlling program flow.

Only two valid boolean values:

true
false

Invalid boolean values:

True        // Capitalized (Java is case-sensitive)
FALSE       // Capitalized
"true"      // String, not boolean
1           // Number, not boolean
0           // Number, not boolean

Common uses for boolean:

Example declarations:

boolean isRaining;
boolean gameOver;
boolean isPassing;

Variables

What is a Variable?

A variable is a storage location that holds a value, which can change while the program is running. Every variable has:

Think of a variable as a labeled box that holds a specific type of item.

Declaring Variables

Before you can use a variable, you must declare it by specifying its type and name:

int age;
double price;
boolean isValid;

Variable naming rules:

Naming conventions (not required, but standard):

Valid variable names:

int numberOfDays;
double price2;
boolean _isActive;
int $amount;

Invalid variable names:

int 2ndPlace;      // Cannot start with digit
double my price;   // Cannot contain spaces
boolean class;     // Cannot use Java keyword
int first-name;    // Cannot use hyphen

Storing Values

Variables of primitive types hold primitive values from that type. Before using a variable in calculations or expressions, it must be assigned a value.

int count;          // Declared but not initialized
count = 10;         // Now initialized with value 10

double temperature;
temperature = 98.6;

boolean isOpen;
isOpen = true;

You can also declare and initialize a variable in one statement:

int count = 10;
double temperature = 98.6;
boolean isOpen = true;

Primitive vs. Reference Variable Storage

This distinction becomes important as you progress in the course:

Primitive variables store the actual value:

int x = 5;          // x contains the value 5

Reference variables store a memory address pointing to an object:

String name = "Alice";  // name contains a reference to "Alice"

If you assign null to a reference variable, it indicates there is no object:

String text = null;     // text refers to no object

Data Type Comparison

$\begin{array}{llll}\mathbf{Type}& \mathbf{Values}& \mathbf{Memory}& \mathbf{Example}\mathbf{Uses}\\ \text{int}& \text{Whole numbers}& \text{4 bytes}& \text{Counting, ages, indices}\\ \text{double}& \text{Decimal numbers}& \text{8 bytes}& \text{Measurements, prices, scientific}\\ \text{boolean}& \text{true or false}& \text{1 bit}& \text{Decisions, flags, conditions}\end{array}$

Common Mistakes

Mistake 1: Using the wrong data type

// WRONG - age won't have decimals
double age = 16;

// CORRECT
int age = 16;

// WRONG - GPA needs decimals
int gpa = 3;

// CORRECT
double gpa = 3.75;

Mistake 2: Not declaring a variable before using it

// WRONG
score = 100;            // What type is score?

// CORRECT
int score;
score = 100;

Mistake 3: Using invalid variable names

// WRONG
int 1stPlace;           // Starts with digit
double my-score;        // Contains hyphen
boolean return;         // Java keyword

// CORRECT
int firstPlace;
double myScore;
boolean shouldReturn;

Mistake 4: Confusing boolean values

// WRONG
boolean isValid = "true";   // String, not boolean
boolean flag = 1;           // Number, not boolean

// CORRECT
boolean isValid = true;
boolean flag = false;

Practice Problems