What is definite assignment in Java, and why does the compiler reject reading a local variable that might be unassigned?

## What problem this solves In Java a **local variable** (a variable declared inside a method, constructor, or block) does **not** receive a default value. Compare this with **fields** (variables declared at class level), which are automatically initialized to `0`, `false`, `null`, etc. If locals also silently defaulted, you could accidentally read a variable you forgot to set and get meaningless data. To prevent that entire bug category, the Java Language Specification (JLS, the official rulebook for the language) requires that a local variable be **definitely assigned** before any access that reads its value. ## What "definitely assigned" means At every point in the program, the compiler classifies a variable as either *definitely assigned* (DA) or *not*. A variable is DA at a given point if **every possible execution path** that reaches that point has already executed an assignment to it. "Every path" is the key phrase: it is not enough for *some* branch to assign the variable — *all* branches that can reach the read must. ```java int x; if (cond) { x = 1; } System.out.println(x); // ERROR: if cond is false, x is unassigned here ``` The `else` path (cond false) reaches the `println` without assigning `x`, so `x` is **not** definitely assigned there, and the compiler rejects it. ```java int x; if (cond) { x = 1; } else { x = 2; } System.out.println(x); // OK: every path assigns x ``` Now both branches assign `x`, so after the `if/else` it is definitely assigned. ## It is static and conservative The analysis runs at **compile time** and looks only at the *shape* of the code — the control-flow structure — never at the runtime values of variables. So it is **conservative**: it may reject code that, by human reasoning, would always assign the variable. ```java int x; if (true) { // a true constant: the compiler DOES special-case this x = 1; } System.out.println(x); // OK only because `true` is a constant expression ``` The compiler does evaluate **constant expressions** (`true`, `false`, `1 == 1`) when deciding reachability, but it will not reason about an ordinary boolean variable whose value it cannot know statically. ## Reading vs. assigning The rule only constrains a variable's **use as a value (a read)**. Assigning a value is always fine; declaring is fine. So: ```java int x; // declaration only — fine x = compute(); // assignment — fine int y = x; // read of x — requires x be definitely assigned (it is) ``` ## Where it applies Definite assignment governs **local variables** and **blank `final` fields/parameters** (finals with no initializer). It does **not** apply to ordinary non-final fields, because those have language-defined defaults. The rules cover all control structures — `if`, `while`, `for`, `do`, `switch`, `try/catch/finally`, the conditional operator `?:`, `&&`/`||`/`!`, `break`/`continue`/`return`/`throw` — each with its own JLS rule for how DA flows through it. ## Why it matters This check turns a common runtime mistake (using an uninitialized value) into an immediate compile-time error, with zero runtime cost. It is one of the reasons Java programs rarely exhibit the "reading garbage memory" bugs familiar from languages where locals are not checked.