Welcome to the first post in our series on the static keyword in Java! In this series, we’ll break down various concepts like static variables, methods, nested classes, and more, covering them in bite-sized posts to help you grasp these concepts easily.

In this post, we’ll focus on static blocks—a special feature used to execute code once during class loading. You’ll learn what static blocks are, how they work, and when to use them through a hands-on example.

What is a Static Block in Java?

A static block is a code block marked with the static keyword that runs exactly once when the class is loaded into memory by the JVM’s ClassLoader.

Key Characteristics:

Executed once during class loading.
Runs before the main method or any constructor.
Can initialize static variables or call static methods.

Code Example: Static Block Execution

Below is a program demonstrating the behavior of a static block along with constructors and initializer blocks for comparison.

Program: Static Block in Action

package keywords.static_keyword;

public class StaticBlock {

    public static int constantNumber;
    private int number;

    // Static Block: Executes once when the class is loaded.
    static {
        constantNumber = 100;
        System.out.println("Static Block Invoked: " + constantNumber);
    }

    // Constructor: Called whenever a new object is created.
    public StaticBlock() {
        System.out.println("Default Constructor invoked: " + number);
    }

    // Constructor: Called whenever a new object is created.
    public StaticBlock(int num) {
        System.out.println("Parameterized Constructor invoked: " +
        (number + num));
    }

    // Initializer Block: Runs before EVERY constructor call.
    {
        System.out.println("Initializer Block Invoked");
        number = 60 + constantNumber;
    }

    public static void main(String[] args) {
        // Objects created to observe initializer and constructor behavior.
        StaticBlock obj1 = new StaticBlock();
        StaticBlock obj2 = new StaticBlock(200);
    }
}

Explanation of the Output

Output:

Static Block Invoked: 100
Initializer Block Invoked
Default Constructor invoked: 0
Initializer Block Invoked
Parameterized Constructor invoked: 260

What Happened?

Static Block Execution
- The static block was executed once when the class was loaded, initializing constantNumber to 100.
Object Creation and Initializer Block
- For each object creation, the initializer block ran before the constructor.
Constructor Behavior
- We observed both the default and parameterized constructors in action.

When to Use Static Blocks

Initializing Static Variables: Static blocks are ideal for initializing static variables that require complex logic or external resources.

Executing Code Once: If you need to run a piece of code only once during the entire lifecycle of the class (e.g., logging or resource loading), a static block is the right place.

Calling Static Methods Automatically: You can call static methods inside the static block, ensuring they execute without being explicitly invoked in main.

Key Differences Between Static Blocks and Other Blocks

Feature	Static Block	Initializer Block	Constructor
When Executed	On class loading	Before each constructor call	On object creation
How Many Times	Once	Every time an object is created	Every time an object is created
Purpose	Initialize static members	Initialize instance variables	Initialize the object
Access Restrictions	Can’t access non-static members directly	Can access both static and non-static	Can access both static and non-static

Conclusion

Static blocks in Java are a powerful tool to execute code once during class loading. They offer a way to initialize static variables, call static methods, and manage resources efficiently. Understanding static blocks will help you write better, optimized Java code—and ace those tricky interview questions!

Stay tuned for upcoming posts where we explore more essential concepts related to the static keyword.

Happy Coding!

Static Keyword: Decoding Static Blocks in Java