How can a final instance field be initialized, and what guarantees does the compiler enforce for blank final fields?

## final on an instance field An **instance field** is a variable that belongs to each object. Marking it `final` means it must be assigned **exactly once** and then never changed. Unlike a local, a `final` instance field has three legal places to be assigned: 1. **At the declaration:** ```java private final int max = 100; ``` 2. **In an instance initializer block** (a `{ ... }` block in the class body): ```java private final int max; { max = 100; } ``` 3. **In a constructor:** ```java private final int max; MyClass(int m) { this.max = m; } ``` A field declared `final` but not assigned at its declaration is a **blank final** — extremely common for binding constructor arguments into immutable objects. ## What the compiler guarantees (definite assignment) For every constructor, the compiler proves two things via **definite assignment analysis**: - **At least once:** every `final` field is assigned on **every** code path before the constructor returns. You cannot leave a final field unset. - **At most once:** no `final` field is assigned a second time on any path. ```java final int x; MyClass(boolean b) { if (b) { x = 1; } // ERROR if no else: x might be unassigned } ``` This must hold **independently for each constructor**. If you have multiple constructors, each must fully initialize the final fields. ## Constructor chaining with this(...) If one constructor delegates to another with `this(...)`, the **delegated-to** constructor is responsible for the assignment; the delegating one must **not** also assign (that would be a second assignment): ```java final int x; MyClass() { this(0); } // delegates MyClass(int v) { this.x = v; } // does the single assignment ``` ## Static final fields The analogous rule applies to `static final` fields, which may be assigned at declaration or in a **static initializer block**, exactly once across all static-init paths. ## The Java Memory Model safe-publication guarantee There is a deeper, runtime guarantee for `final` fields. The **Java Memory Model (JMM)** promises that if an object is properly constructed — meaning the `this` reference does **not escape** during construction — then any thread that later obtains a reference to the object is guaranteed to see the **correctly initialized values** of its `final` fields, **without any synchronization**. This is the foundation of **safe immutable objects**: a class with only `final` fields, no escaping `this`, and no mutators can be freely shared across threads. Non-final fields enjoy no such guarantee — another thread might see their default (zero/null) values due to reordering. ```java public final class Money { private final long cents; // final -> safely published public Money(long cents) { this.cents = cents; } // this never escapes } ``` ## Why this matters - It lets you build **immutable, thread-safe** value types with no locks. - It documents required, never-changing dependencies (constructor-injected collaborators). - The compiler catches forgotten or duplicated initialization at build time.