Static Initialization Blocks

java

static-initialization

complex-assignments

static-blocks

byNikita Barsukov·Sep 13, 2024

Utilize a static initialization block for configuring static variables prior to class use. It only triggers once, at class load time.

Consider this Java snippet:

class Example {
    static int staticValue;

    static {
        staticValue = 42; // Hitchhiker's Guide to the Galaxy fans, anyone? ;) 
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Example.staticValue); // Prints: 42 
    }
}

The static block initializes staticValue when loading the Example class, not when creating an instance or invoking static methods.

Static block in action

Static blocks, signified by static {...}, offer a dedicated space for complex initialization logic needed beyond the capabilities of field assignment. In initializing static fields, there are instances where tasks like exception handling, loading external resources, or registering JDBC drivers need to be executed, making static blocks the perfect venue for convening such operations.

Executing complex assignments with static blocks

Static blocks become incredibly handy when working with static final fields that necessitate complex assignments:

class Configuration {
    static final Properties config;
    
    static {
        config = new Properties();
        try {
            // Configuring... Please wait. Your cup of coffee could help at this point :)
            config.load(new FileInputStream("config.properties")); 
        } catch (IOException e) {
            throw new RuntimeException("Failed to load configuration", e);
        }
    }
}

Prior actions with static blocks

Static blocks play a great role in undertaking actions, such as loading native libraries or initializing logging frameworks, that may need to be carried out before the class is employed:

class LibraryLoader {
    static {
        System.loadLibrary("libThatMakesJavaRockHarder"); // Load 'n roll, rockstar!
    }
}

Choosing between static blocks and static methods

Where static methods can be used for initializing static variables, static blocks guarantee the code gets executed without the need for an explicit method call, making them less ritualistic. In other words, developers will not need to chant mantras to remember calling these methods!

Application of static blocks and alternatives

Neatness vs static blocks

While some developers worry about static blocks messing up a neat class definition, they can actually provide a harmonized structure by concentrating initialization code away from the static variable declarations.

Alternatives for static blocks

Singleton patterns, static factory methods, or the static holder idiom may be employed as alternatives to static blocks when initializing:

class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        // Singleton in the making...
    }

    public static Singleton getInstance() {
        return INSTANCE; // One instance to rule them all!
    }
}

Watch out for pitfalls

Execution order matters

Grasping the execution order is essential. Static blocks and static variable initializers execute in the sequence they are presented in the code. Be mindful of this to prevent dependencies that could befuddle you later.

Performance consideration

Weighty initialization code inside static blocks can linger and affect performance by delaying class readiness.

Memory implications

Upon execution, the static variables initialized remain in memory as long as the class stays loaded, potentially increasing your application's memory footprint. Keep this in mind when working with hefty data or resources.

explain-codes / Java / Static Initialization Blocks

Linked

When to use static methods



Difference between Static and final?



How to initialize HashSet values by construction?



What is a good use case for static import of methods?



How should I use try-with-resources with JDBC?

