Understanding Variables and Primitive Types in Java

A program is built from many pieces: classes, variables, and subroutines. To work with any of these pieces, the program must be able to refer to each one by name. In Java, these names are called identifiers. Choosing an identifier looks simple, but the language applies strict rules to every identifier, and a name that looks readable to a person may still be rejected by the compiler. This article builds the ideas you need to name things correctly, to understand what a variable actually is, and to trace what happens when Java runs an assignment.

The key word in that definition is sequence. An identifier is not limited to a single character, and it is not any text you happen to type. It is a particular kind of character sequence that Java is willing to accept as a name. The same naming system covers classes, variables, and subroutines, so a rule you learn for variable names also applies when you name other program parts.

A common misconception is that any readable text can become an identifier. It cannot. Java applies rules to the characters and to the structure of every identifier, so a name must satisfy those rules before the program can use it.

Java states two rules for the form of an identifier. First, an identifier must begin with a letter or an underscore. Second, after that first character, it must consist entirely of letters, digits, and underscores. Put simply, the first character has the fewest choices, and every later character may use letters, digits, or underscores.

The rule about the first character is the one that most often surprises beginners. A digit may appear later in a name, as in score_2, but it may never be the first character. The same letters arranged differently can therefore produce a valid name or an invalid one.

Uppercase and lowercase letters are different in Java, so capitalization changes an identifier. Score, score, and SCORE are three separate names. A program that declares one of them does not automatically declare the others, and a reference to SCORE will not find a variable declared as score. When you read code, check the capitalization of every name as carefully as its spelling.

Reserved words are words the language already uses for its own purposes, such as the words that make up Java's statements. Because the language has claimed them, they cannot also be used as names for your classes, variables, or subroutines. A name that is spelled correctly and follows the character rules can still fail if it happens to be a reserved word, so it is worth checking a candidate name against the reserved list when a compiler rejects it.

A common beginner belief is that a variable is simply another name for a piece of data. That idea is useful at first, but it hides an important distinction. In Java, a variable name refers to a location in memory that can hold data. The computer keeps track of the actual memory location, so the programmer can work with the name instead of a numerical address.

A helpful picture is a labeled container. The label identifies the container, while the data is what the container currently holds. The container stays the same even when its contents are replaced. This is why one variable can be associated with different values at different points during a program. The name stays fixed, the location stays fixed, and the value inside can change.

The diagram separates the three things that are easy to confuse. The name score is the label a program uses. The memory location is the container that the name refers to. The value 10 is the data the container holds right now. If the value is later replaced, the name and the location remain the same, and only the contents change. The name is therefore not the data itself.

An assignment is an instruction for the computer to carry out, not a permanent statement of fact. Its general form is a variable, followed by an equals sign, followed by an expression, and then a semicolon.

Execution follows a specific direction. Java does not look at the variable on the left first. It first evaluates the expression on the right, which produces a result. Then it places that result into the location identified by the variable on the left. If that location already holds data, the new result replaces the old data.

The same variable can play two different roles in one assignment. On the left side, the variable identifies the location that will receive a result. Inside the expression on the right side, a variable contributes the value currently stored in its location. The worked example above used price and tax only on the right, where each one supplied its current value. A variable on the left, such as total, was only a destination.

This rule means that the order of statements matters. A variable on the right is read at the moment the expression is evaluated, so the value it provides depends on the assignments that ran before. Tracing a program means keeping track of what each variable holds at each step, rather than assuming a variable holds the value you expected.

The equals sign in an assignment resembles the equals sign in a mathematical equation, but the two uses have different meanings. In Java, an assignment tells the computer to perform an operation at a particular time. It does not claim that the two sides will remain equal forever. The statement count = count + 1; would be a contradiction if read as an equation, since no number equals one more than itself. As an instruction, it is perfectly sensible: take the current value of count, add one, and store the result back in count.