Fields modified with the static keyword are known as static member variables or class variables. Fields without this modifier are instance variables. The primary distinction lies in memory allocation: static variables have a single shared copy across all instances, while instance variables have separate copies for each object. Static variables are initialized once when the class is loaded by the JVM and can be accessed via the class name or object references, though class name access is preferred. In contrast, instance variables are created anew with each object enstantiation and maintain independent states.

Static Methods

Static methods belong to the class rather than any specific instance. They can be invoked using the class name directly or through object references. Within static methods, the this and super keywords are unavailable, and direct access to instance variables or instance methods is prohibited. Static methods can only interact with other static members of the same class. Since static methods are not tied to object instances, they cannot be abstract and must provide a concrete implementation.

Static Initialization Blocks

Static iintialization blocks are special code segments enclosed in braces and preceded by the static keyword. A class may contain multiple such blocks, which the JVM executes in the order they appear during class loading. Each static block runs exactly once per class lifecycle. Unlike instance initialization blocks (which execute before constructors during object creation), static blocks execute during the class loading phase, not during instantiation.

Static Nested Classes

Declaring a nested class as static creates a static nested class that can be instantiated without requiring an instance of the outer class. This distinguishes them from enner classes, which are tied to specific outer class instances.

Example Demonstration

public class StaticDemo {
    // Instance initialization block
    {
        System.out.println("Instance block executed.");
    }
    
    // Static initialization block
    static {
        System.out.println("Static block executed.");
    }
    
    // Static field
    public static String staticData = "Static field value.";
    
    // Static method
    public static void staticOperation() {
        System.out.println("Static method executed.");
    }
    
    // Static nested class
    public static class NestedClass {
        public NestedClass() {
            System.out.println("Static nested class constructor executed.");
        }
    }
    
    // Private constructor
    private StaticDemo() {
        System.out.println("Constructor executed.");
    }
    
    public static void main(String[] args) {
        StaticDemo obj1 = new StaticDemo();
        StaticDemo obj2 = new StaticDemo();
        System.out.println("------------Objects created.----------------");
        
        // Access via class name
        StaticDemo.staticOperation();
        System.out.println(StaticDemo.staticData);
        
        // Access via instance (not recommended)
        obj1.staticOperation();
        System.out.println(obj1.staticData);
        
        // Instantiate static nested class
        new StaticDemo.NestedClass();
    }
}

Execution Output

Static block executed.
Instance block executed.
Constructor executed.
Instance block executed.
Constructor executed.
------------Objects created.----------------
Static method executed.
Static field value.
Static method executed.
Static field value.
Static nested class constructor executed.