Initialization

## What 'final' means on a field In Java, the keyword **final** applied to a field (a variable that belongs to an object or class) means the field can be **assigned a value only once**. After that single assignment, any attempt to change it is a **compile-time error** — the program will not compile. A **field** is a variable declared inside a class but outside any method, e.g. `private final int x;`. An **instance field** belongs to each object; a **static field** belongs to the class itself. ## 'Definitely assigned exactly once' The Java Language Specification requires that a `final` field be **definitely assigned exactly once**. Two parts: - **Definitely assigned** — on *every* possible execution path that finishes constructing the object, the field has been given a value. The compiler performs *definite-assignment analysis*: it traces all branches (if/else, switch, loops, try/catch) and proves the field is set on each one. If even one path could leave it unset, compilation fails. - **Exactly once** — the field is assigned **no more than one time**. Assigning it a second time (even on a different branch where it was already set) is a compile error. ## Where you may assign it There are exactly three legal places to assign a `final` instance field: 1. **At the declaration (field initializer):** ```java private final int size = 10; ``` 2. **In an instance initializer block** (a `{ ... }` block in the class body that runs before constructor bodies): ```java private final int size; { size = 10; } ``` 3. **In a constructor** — but then it must be assigned in *every* constructor on every path (this is the 'blank final' case, covered separately). A `final` field is assigned in **one** of these mechanisms, not several. For example, if you give it a value at the declaration, you cannot also assign it in a constructor. ## Why the rule exists The point is **immutability**: once an object is fully constructed, a `final` field never changes. This makes the value safe to read repeatedly, easier to reason about, and (under the Java Memory Model) safely visible to other threads after construction. The compiler's exactly-once guarantee means you can trust that a `final` field is never accidentally reassigned or left as a default value. ## What it does NOT mean - `final` makes the **reference/variable** unchangeable, not the **object it points to**. `final List<String> list = new ArrayList<>();` still lets you call `list.add(...)` — the list contents are mutable; you just can't repoint `list`. - `final` on a field is unrelated to `final` on a method (can't be overridden) or `final` on a class (can't be extended). ## A worked example ```java class Circle { private final double radius; // blank final private final double pi = 3.14159; // assigned at declaration Circle(double r) { radius = r; // assigned exactly once in the constructor } } ``` Here `pi` is set at its declaration; `radius` is a blank final set once in the constructor. Both are 'definitely assigned exactly once'.