Variables: Named Boxes for Values

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Variable

A named place in memory that holds one value. You can read it and, unless it's final, change it.

Type

The kind of value a variable may hold, such as a whole number (int), a decimal (double) or text (String). It also fixes how much memory the value takes.

Declaration

The line that creates a variable by stating its type and name, like int age;.

Assignment

Storing a value into a variable with =. The right side is worked out first, then stored on the left.

Initialization

The very first assignment of a variable. int age = 12; declares and initializes in one line.

Local variable

A variable declared inside a method. It exists only while that method is running.

Statically typed

Every variable's type is known when the code is compiled, so type mistakes are caught before the program runs.

Identifier

Any name you invent in code: a variable, method or class name.

Stack frame

A small private area of memory a method gets while it runs. Its local variables live there and vanish when the method returns.

1. 1

   Predict, then run

   Open the first example. Before running it, add the line coins = coins * 2; after the second print and write down what the next print will show. Then add a print and run it to check.

   You should see 150 coins, because coins already held 75 at that point.

2. 2

   Break the swap

   In the swap example, delete the temp lines and try to swap a and b using only a = b; b = a;. Run it and explain the output in one sentence.

3. 3

   Make the compiler complain

   In the definite-assignment example, delete the whole else { ... } block and run. Read the error: the compiler has spotted that when temperature is 30 or less, advice is never assigned.

   terminalcopy cmd

   $ javac Main.java

   ── expected output ──

   Main.java:10: error: variable advice might not have been initialized

   System.out.println("It is " + temperature + " degrees: " + advice);

   ^

   1 error

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

public class Main {
    public static void main(String[] args) {
        int score;
        System.out.println(score);
    }
}

1. 1

   A declaration like int score; tells the compiler two facts: there is a variable called score, and it can only ever hold an int (a whole number). Java is statically typed: the type is fixed when you write the code and checked by the compiler before the program ever runs.

2. 2

   Assignment uses =, which means *store the value on the right into the variable on the left*. It is not the maths 'equals'. score = score + 10; is perfectly sensible: read the old value, add 10, store the result back.

3. 3

   A local variable (one declared inside a method) has no default value. The compiler tracks every path through your code and refuses to compile a read of a variable that might not have been given a value yet. This rule is called definite assignment, and it removes a whole class of bugs that C programs suffer from (reading leftover garbage memory).

4. 4

   Names follow strict rules: they may contain letters, digits, _ and $, must not start with a digit, are case-sensitive (total and Total are different variables), and can't be a keyword like int or class. By convention Java uses camelCase for variables: studentCount, maxSpeed, isReady.

5. 5

   A local variable lives in the current method's stack frame, a small block of memory created when the method starts and thrown away when it returns. For primitive types like int the value itself sits in that slot. For objects like String the slot holds a reference (an arrow) to the object on the heap. Topic 3.11 draws this picture in full.

6. 6

   A variable is visible only inside the { } block where it is declared, from the line of its declaration onwards. This region is its scope. Two variables in the same scope can't share a name. Topic 3.6 covers scope and lifetime in depth.

• ↔

  Declaring a variable at first use keeps scope small and code readable, but declaring it earlier is sometimes needed so that several branches can assign it (as in the advice example).

• ↔

  Short names (i, n) keep tight loops readable; long descriptive names make business logic self-explaining. Match name length to how far away the reader is from the declaration.

• I can declare, initialize and reassign a variable and explain what = really does.

• I can explain definite assignment and fix 'might not have been initialized'.

• I know the naming rules and the camelCase convention.

• I can describe where a local variable lives in memory and when it disappears.

• I can swap two variables correctly and explain why the naive version fails.