Scope and Lifetime of Variables

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

Scope

The part of the source code where a variable's name can be used.

Lifetime

The period during a run when a variable's storage exists in memory.

Block

A group of statements between { and }. Method bodies, loop bodies and if branches are blocks.

Local variable

A variable declared inside a method (including parameters). It exists only during that method call.

Field

A variable declared directly inside a class, outside any method. Each object has its own copy, unless it's static.

Static field

A field marked static: one copy shared by the whole class, living as long as the class is loaded.

Shadowing

When a local variable has the same name as a field, so the plain name refers to the local and hides the field.

Definite assignment

The compiler rule that a local variable must surely have been given a value before it's read.

1. 1

   Use a loop variable after the loop

   In "Block scope in action", add System.out.println(i); after the for loop. Read the error. Then move the declaration before the loop (int i; for (i = 1; ...)) and see it print 4.

2. 2

   Make visit remember with a local

   In "Locals reset every call", try to make local count calls by moving local++ above the declaration or removing = 0. Neither works. Convince yourself why only a field can carry a value across calls.

3. 3

   Trigger definite assignment

   Write int x; if (args.length > 0) { x = 1; } System.out.println(x);. Read the error, then fix it with an else branch that also assigns x.

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) {
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
        }
        System.out.println(i);
    }
}

public class Main {
    public static void main(String[] args) {
        int x = 1;
        if (x > 0) {
            int x = 2;
        }
    }
}

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

1. 1

   Scope is a compile-time idea: the region of source code where a name is visible. A local variable's scope runs from its declaration to the end of the block ({ ... }) it's declared in. Outside that block, the compiler reports cannot find symbol.

2. 2

   A for loop's variable (for (int i = 0; ...)) is scoped to the loop. Parameters are scoped to the whole method body. A variable declared inside an if, else or loop body is gone after that body's closing brace.

3. 3

   Lifetime is a run-time idea: how long the storage exists. A local variable lives in its method call's stack frame and disappears when the call returns. Every call gets fresh locals, which is why a local counter starts again at zero each time.

4. 4

   Fields belong to an object and live as long as the object does (Topic 4.2). Static fields belong to the class and live as long as the class is loaded, typically the whole program run. Use them when a value must survive between calls.

5. 5

   Locals have no default value: the compiler refuses to read one before it's definitely assigned (variable x might not have been initialized). Fields and array elements, in contrast, start at 0, false or null.

6. 6

   Java forbids declaring a local with the same name as another local that's still in scope (variable x is already defined). A local may have the same name as a field, which shadows the field; that's common in constructors and setters, where this.name = name is used (Topic 4.4).

• ↔

  Static fields make data outlive calls, but they're shared by everything in the program (and every thread), which makes code harder to test and reason about. Prefer passing values as parameters and returning results.

• ↔

  Very small scopes add a few extra declarations, but each variable then has an obvious purpose and can't be changed by unrelated code.

• Done when you can point to the exact region where any variable is in scope.

• Done when you can explain scope (compile time) vs lifetime (run time).

• Done when you can fix cannot find symbol, already defined and might not have been initialized errors.

• Done when you can choose between a local, an instance field and a static field based on how long the value must live.

• Done when you can explain shadowing and reach a shadowed static field.