Scope and Lifetime of Variables in Java

Every variable in Java has two properties worth understanding independently: its scope (the region of code where the variable is accessible) and its lifetime (how long the variable exists in memory). Confusing the two is a common source of bugs.

The three main categories

Local variables

Declared inside a method, constructor, or block. They live on the stack and disappear the moment the enclosing block finishes.

public void greet(String name) {
    String message = "Hello, " + name; // local to greet()
    System.out.println(message);
} // 'message' is gone here

Local variables must be initialised before first use — the compiler enforces it. Unlike instance variables, they do not have a default value.

Block-scoped variables

Any { } block introduces its own scope, including for, if, try and even standalone blocks:

for (int i = 0; i < 10; i++) {
    int square = i * i; // 'square' only exists in this iteration
}
// Cannot use 'i' or 'square' here — compile error

This is why reusing variable names across blocks is a readability improvement rather than a bug.

Method parameters

Parameters behave exactly like local variables — scoped to the method, allocated on the stack, destroyed on return:

public int multiplyBy(int x) {
    return x * 2; // 'x' alive only during the call
}

Instance variables

Declared directly inside a class, outside any method, without static. Each object of the class has its own copy. They live as long as the owning object.

public class Counter {
    private int value = 0; // instance variable

    public void increment() { value++; }
    public int get() { return value; }
}

Counter a = new Counter();
Counter b = new Counter();
a.increment();
// a.value == 1, b.value == 0 — independent copies

Instance variables receive a default value if not initialised (0, null, false), unlike local variables.

Static (class) variables

Declared with the static keyword. Only one copy exists, shared by every instance of the class. The variable is alive from the moment the class is loaded until the class loader itself is unloaded (usually until the JVM exits).

public class User {
    public static int count = 0;   // shared by all instances
    private final int id;

    public User() {
        this.id = ++count;
    }
}

User.count; // access without any instance

Variable shadowing

A local variable with the same name as an instance variable shadows the instance one inside its scope. Use this. to refer to the instance field explicitly:

public class Box {
    private int width;

    public void setWidth(int width) {
        this.width = width; // 'width' alone would refer to the parameter
    }
}

A complete example

public class Demo {
    static String prefix = "[LOG] ";     // static, lives for the JVM
    private int instanceCount = 0;       // instance, dies with the object

    public void process(String input) {  // 'input' is a local parameter
        int localVar = input.length();   // local, dies with the method
        for (int i = 0; i < localVar; i++) { // 'i' is block-scoped
            int doubled = i * 2;
            System.out.println(prefix + doubled);
        }
        instanceCount++;                 // persists until object is GC'd
    }
}

Best practices

1. Keep scope as narrow as possible. Declare variables at their first use, not at the top of the method.
2. Prefer final for locals. Makes intent clear and unlocks use inside lambdas.
3. Avoid unnecessary static. Static variables are effectively globals and make testing harder.
4. Never rely on default values for instance variables — explicit initialisation is clearer.
5. Use this. to disambiguate shadowed parameters, especially in setters and constructors.

Scope and lifetime are enforced by the compiler and the JVM respectively. Understanding both lets you reason about memory, garbage collection and concurrency far more confidently.