1.2 Variables and Data Types

What you need to know

• A variable is a named memory location with a declared type. Declaration: int count;. Declaration with initialization: double price = 9.99;
• Primitive types on the exam: int (whole numbers), double (decimals), boolean (true/false). A primitive variable stores the value itself.
• Reference types (like String and every other class) store the address of an object, not the object. Two reference variables can point to the same object.
• int has a fixed range: Integer.MIN_VALUE (−2,147,483,648) to Integer.MAX_VALUE (2,147,483,647). Exceeding it causes overflow — it wraps around silently, no error.
• The final keyword makes a variable a constant: final int MAX = 100;. Assigning to it again is a compile-time error.
• Naming: variables start with a lowercase letter (totalScore); constants are all caps (MAX_SIZE); classes start uppercase (String). Names must be declared before use and are case-sensitive.

Worked example

int age = 17;
double gpa = 3.85;
boolean isSenior = true;
String name = "Ram";
final double TAX = 0.07;
age = 18;        // fine
TAX = 0.08;      // compile-time error: cannot assign to final

Four types, four kinds of value. name holds a reference to a String object; the other three hold their values directly. That distinction matters in 1.13 and 3.6.

Going deeper

The nuance, edge cases, and connections that turn a 3 into a 5.

• The exam's three primitives are int, double, and boolean. Java has others (char, long, float…) but the CED excludes them. If you see char on the exam, it's in a String context and the question will explain.
• int is a 32-bit signed integer: exactly −2,147,483,648 to 2,147,483,647. Integer.MAX_VALUE and Integer.MIN_VALUE are on the reference sheet. Overflow wraps silently: MAX + 1 = MIN. No exception.
• double holds decimals with about 15–16 significant digits of precision. Not every decimal is exact — 0.1 + 0.2 is 0.30000000000000004. This is why comparing doubles with == is unreliable.
• A variable must be declared before use and initialized before its value is read. A declared-but-unassigned local variable is a compile error when read. (Instance variables are different — they get defaults. That's 3.3.)
• Naming rules: start with a letter, _, or $; no spaces; case-sensitive; can't be a keyword. Conventions: camelCase for variables and methods, PascalCase for classes, ALL_CAPS for constants. Conventions aren't enforced by the compiler but the exam follows them and expects you to.
• final variables must be initialized exactly once. Attempting a second assignment is a compile error. Constants make code readable (MAX_SPEED instead of 120) and safe from accidental change.

Mistakes that cost points

• Assigning a double to an int. int x = 3.7; won't compile. Needs a cast. The reverse (double d = 3;) is fine.
• Expecting overflow to throw. It wraps. Integer.MAX_VALUE + 1 is a large negative number.
• Assuming a local variable defaults to 0. It has no default. Reading it before assignment is a compile error.
• Using a keyword as a name. int class = 5; won't compile.

Practice questions

Written in the style of the real exam. Try each one before revealing the answer.