> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java Static Field A static field in Java is a class-level variable declared with the `static` modifier. It belongs to the class itself rather than to any specific instance, meaning all instances of the class share a single, globally accessible copy of the variable in memory. ```java theme={"dark"} public class Configuration { // Static field declaration public static int timeoutLimit = 30; // Static constant declaration public static final String ENVIRONMENT = "PRODUCTION"; public static void main(String[] args) { // Accessing the static field directly via the class name Configuration.timeoutLimit = 60; } } ``` ## Memory Allocation and Lifecycle Starting in Java 7, static fields are stored on the **Java Heap**. They are allocated as part of the `java.lang.Class` object representing the class, rather than in the Metaspace (which stores class metadata) or the deprecated Permanent Generation. The lifecycle of a static field is governed by the JVM's class execution phases: 1. **Initialization:** Static fields are initialized exactly once during the class initialization phase (when the JVM executes the `` method). This phase is triggered by the first *active use* of the class, such as instantiating the class, invoking a static method, or accessing a static field—not merely when the class is loaded by the `ClassLoader`. 2. **Destruction:** The field remains in memory until the class is unloaded by the JVM. Class unloading typically only occurs when the `ClassLoader` that loaded the class is garbage collected. ## Access Resolution Static fields are resolved at compile-time. While Java syntax permits accessing a static field through an object reference, the compiler translates this to a class-level access. ```java theme={"dark"} public class State { public static int sharedValue = 0; public static void main(String[] args) { State objA = new State(); State objB = new State(); // Modifying via instance reference (compiles, but poor practice) objA.sharedValue = 5; // The compiler translates the above to State.sharedValue = 5; // Therefore, objB sees the exact same mutation. System.out.println(objB.sharedValue); // Outputs: 5 } } ``` ## Technical Characteristics * **Default Values:** Like instance variables, uninitialized static fields are automatically assigned default values during the preparation phase based on their data type (`0` for numeric primitives, `false` for booleans, and `null` for object references). * **Static Initialization Blocks:** Complex initialization logic for static fields can be placed inside a `static {}` block. These blocks are executed in the order they appear in the source code during the class initialization phase. * **Thread Safety:** Because a static field represents shared state across the entire `ClassLoader`, mutable static fields are inherently vulnerable to race conditions in multithreaded environments. They require explicit synchronization mechanisms (like `synchronized` blocks, `Atomic` classes, or the `volatile` keyword) to ensure thread safety. * **Inheritance:** Static fields are inherited by subclasses. However, they cannot be overridden. If a subclass declares a static field with the same name as a static field in its superclass, it *hides* the superclass field (known as field shadowing) rather than overriding it. Polymorphism does not apply to static fields.

Tired of Poor Java Skills? Fix That With Deep Grasping! Learn More