How does initialization of a static final field (a constant) differ from an instance final field, and what is a compile-time constant?

## Static vs instance - An **instance field** belongs to each object; each `new` creates its own copy. - A **static field** belongs to the **class itself** — there is one shared copy regardless of how many objects exist. Adding `final` to either makes it assign-once. But *when* and *where* differ: | | instance final | static final | |---|---|---| | Belongs to | each object | the class | | Assigned when | during construction | at class initialization (once) | | Assigned where | declaration, instance block, or constructor | declaration or **static initializer block** | | Per-object value? | yes | no — shared | A `static final` field is **never** assigned in a constructor, because constructors run per object and would violate exactly-once across many instances. ## Where you assign a static final Two places: ```java static final int A = 10; // at declaration static final int B; static { B = compute(); } // in a static initializer block ``` A blank `static final` (declared without a value) must be definitely assigned exactly once by the **static initializer**(s), analogous to a blank instance final being assigned by constructors. ## Class initialization timing Static fields and static blocks run **once**, when the class is first **initialized** (lazily, on first active use — e.g. first instance, first static access). This is the **class-load-time** sequence, distinct from per-object instance initialization. ## Compile-time constants (constant expressions) A special, important case: a field that is - `static final`, **and** - of a **primitive type or `String`**, **and** - initialized with a **constant expression** (literals and operations on other compile-time constants), is a **compile-time constant variable**. The JLS lets — and effectively requires — the compiler to **inline** its value wherever it is referenced. The reference disappears from the bytecode and is replaced by the literal value. ```java public static final int MAX = 100; // compile-time constant, inlined at use sites ``` ### The inlining hazard Because the value is copied into *consumers* at their compile time, changing the constant and recompiling **only** the defining class does **not** update consumers that were compiled earlier — they still hold the old literal. You must recompile the consumers too. This is a classic versioning gotcha for public constants in libraries. To avoid inlining (so the value is read at runtime), make it **not** a constant expression, e.g.: ```java public static final int MAX = Integer.valueOf(100); // not a constant expression → read at runtime ``` or compute it in a static block. ## Compile-time constants enable other features Because they are known at compile time, compile-time constants can be used as `case` labels in a `switch`, as annotation element values, and they participate in conditional-compilation-style dead-code elimination (`if (false)` with a constant). Non-constant `static final` fields cannot. ## Summary Static final = one shared, assign-once value set at class-init (declaration or static block), never in a constructor. If it is a primitive/String constant expression it is a compile-time constant and gets inlined into consumers — which is fast but creates a recompile-the-consumers versioning hazard. Instance finals differ: they are per-object and assigned during construction.