Variables in Java — local, instance, static, final, var

A Java variable is a typed name bound to a memory slot. There are four kinds of variable depending on where it's declared, and several modifiers (final, static, volatile) that change its behaviour. The kind decides scope, lifetime and default value.

The four kinds of variable

Scope — where the name is visible

public class Counter {
    private int total;          // instance — visible to all methods of Counter
    private static int count;   // static   — visible without an instance

    public void add(int n) {    // n is a parameter — visible in this method only
        int doubled = n * 2;    // local — visible until '}'
        total += doubled;
        count++;
    }
}

final — assign exactly once

final int LIMIT = 100;
LIMIT = 200; // ❌ "cannot assign a value to final variable LIMIT"

final List<String> names = new ArrayList<>();
names.add("Alice");           // ✅ the reference is final, the list is not

final on a reference variable means the variable can't be reassigned — it doesn't make the object immutable. For true immutability use records or unmodifiable collections.

var — local-variable type inference (Java 10+)

var users    = new ArrayList<User>();    // ArrayList<User>
var headers  = Map.of("X-Trace", "abc"); // Map<String,String>
var session  = repo.findById(id);         // whatever findById returns

// var is for locals only — won't compile here:
private var name;                         // ❌ instance fields can't use var
public var doStuff() { ... }              // ❌ method returns can't use var

Use var when the type is obvious from the right-hand side. Don't use it when the result type is unclear (e.g. var x = service.process(); hides whether you got a List or an Optional).

Naming conventions

• Locals, parameters, instance fields: camelCase — userName, retryCount
• Constants (static final): UPPER_SNAKE — MAX_RETRY, DEFAULT_TIMEOUT_MS
• Boolean fields/methods: prefix with is, has, can — isActive, hasChildren

All sub-topics

• Local variables — scope, definite assignment, var
• Instance variables — fields, encapsulation
• Static variables — class-level state
• final — once-and-only-once assignment

Common mistakes

• Reading an uninitialised local — Java rejects this at compile time. Initialise on declaration.
• Mutable static state — global mutable state is a thread-safety nightmare. Prefer dependency injection.
• Treating final as immutable — see the list example above.
• Shadowing — a local with the same name as a field hides the field. Use this.field = ... to disambiguate (common in setters).

Try it & related tools

The Java Online Compiler shows the "might not be initialised" error in real time. For modern bean patterns without manual getters/setters, see the JSON to POJO tool (records, Lombok, classic).