Question

So I’ve been brushing up on my Java skills as of late and have found a few bits of functionality that I didn’t know about previously. Static and Instance Initializers are two such techniques.

My question is when would one use an initializer instead of including the code in a constructor? I’ve thought of a couple obvious possibilities:

• static/instance initializers can be used to set the value of “final” static/instance variables whereas a constructor cannot

• static initializers can be used to set the value of any static variables in a class, which should be more efficient than having an “if (someStaticVar == null) // do stuff” block of code at the start of each constructor

Both of these cases assume that the code required to set these variables is more complex than simply “var = value”, as otherwise there wouldn’t seem to be any reason to use an initializer instead of simply setting the value when declaring the variable.

However, while these aren’t trivial gains (especially the ability to set a final variable), it does seem that there are a rather limited number of situations in which an initializer should be used.

One can certainly use an initializer for a lot of what is done in a constructor, but I don’t really see the reason to do so. Even if all constructors for a class share a large amount of code, the use of a private initialize() function seems to make more sense to me than using an initializer because it doesn’t lock you into having that code run when writing a new constructor.

Am I missing something? Are there a number of other situations in which an initializer should be used? Or is it really just a rather limited tool to be used in very specific situations?

Answer 1

Static initializers are useful as cletus mentioned and I use them in the same manner. If you have a static variable that is to be initialized when the class is loaded, then a static initializer is the way to go, especially as it allows you to do a complex initialization and still have the static variable be final. This is a big win.

I find “if (someStaticVar == null) // do stuff” to be messy and error prone. If it is initialized statically and declared final, then you avoid the possibility of it being null.

However, I’m confused when you say:

static/instance initializers can be used to set the value of “final”
static/instance variables whereas a constructor cannot

I assume you are saying both:

• static initializers can be used to set the value of “final” static variables whereas a constructor cannot
• instance initializers can be used to set the value of “final” instance variables whereas a constructor cannot

and you are correct on the first point, wrong on the second. You can, for example, do this:

class MyClass {
    private final int counter;
    public MyClass(final int counter) {
        this.counter = counter;
    }
}

Also, when a lot of code is shared between constructors, one of the best ways to handle this is to chain constructors, providing the default values. This makes is pretty clear what is being done:

class MyClass {
    private final int counter;
    public MyClass() {
        this(0);
    }
    public MyClass(final int counter) {
        this.counter = counter;
    }
}