Java - (Static|Dynamic) Initialization blocks

Java Conceptuel Diagram

About

Initialization block are used to initialize field with a complex logics such as:

  • with a function that throw exceptions.
  • check if a particular class is loaded
  • only one execution with the static modifier (for a counter for instance)

Type

Static

static {
    // whatever code is needed for initialization goes here
}

The static initialization block only gets:

  • called once, no matter how many objects of that type you create.
  • executed first (e.g. before your constructor and before any static methods) once the JVM loads your class.

A JDBC driver makes use of a static initializer block to register itself in the DriverManager

Dynamic

{
    // whatever code is needed for initialization goes here
}

The dynamic initialization block gets called every-time a class is instantiated. They act like extensions of constructor methods.

Example

public class InitiablizationBlock {

    static int myVariable;

    static{
        System.out.println("Static");
        myVariable = 1;
    }

    {
        System.out.println("Dynamic block");
    }

    public static void main(String[] args) {
        InitiablizationBlock t = new InitiablizationBlock ();
        InitiablizationBlock t2 = new InitiablizationBlock ();
    }
}

Output:

Static
Dynamic block
Dynamic block

Documentation / Reference





Discover More
Card Puncher Data Processing
Design pattern - The Singleton

The singleton pattern is a design pattern used to implement the mathematical concept of a singleton, by restricting the instantiation of a class to one object. This is useful when exactly one object is...
Java Conceptuel Diagram
Java - (Class|Object|Member) (Initialization|Instantiation)

Class (Initialization|Instantiation) in java. During an class initialization: Java's class loader loads the main method Java's byte code verifier verifies the class. The first initialization...
Java Conceptuel Diagram
Java - Final Modifier

Final is modifier prohibiting value modification. Declaring an entire class final prevents the class from being subclassed. This is particularly useful, for example, when creating an immutable...



Share this page:
Follow us:
Task Runner