block initialization - Why java Instance initializers?

2 Answers

You could indeed put the code at the beginning of every constructor. However, that's precisely the point of an instance initializer: its code is applied to all constructors, which can be handy if you have many constructors and a bit of code that is common to all of them.

(If you're just starting out with programming, you might not have known that it is possible to create many constructors for the same class (as long as they take different parameters); this is known as constructor overloading. If you only have one constructor, then an instance initializer is indeed not very useful (Edit: Unless you abuse it in creative fashions, as illustrated in the other answers).)

vs constructor static

This question already has an answer here:

What is the sense of "Instance Initializers" in Java ?
Can't we just put that block of code at the beginning of the constructor instead?

Since all of the code examples here use anonymous classes, I threw together this (slightly horrifying) class that demonstrates using instance initializers in a "proper" class. You can use them to do complex processing or handle exceptions at initialization time. Notice that these blocks are run before the constructor is run, but the constructor is run before initializers in a child class are run:

import java.util.Scanner;

public  class InstanceInitializer {
    int x;
        try {
            System.out.print("Enter a number: ");
            x = Integer.parseInt(new Scanner(;
        } catch (NumberFormatException e) {
            x = 0;

    String y;
        System.out.print("Enter a string: ");
        y = new Scanner(;
        for(int i = 0; i < 3; i++)
            y += y;

    public InstanceInitializer() {
        System.out.println("The value of x is "+x);
        System.out.println("The value of y is "+y);

    public static class ChildInstanceInitializer extends InstanceInitializer {
            y = "a new value set by the child AFTER construction";

    public static void main(String[] args){
        new InstanceInitializer();
        new InstanceInitializer();
        System.out.println(new ChildInstanceInitializer().y);
        // This is essentially the same as:
        System.out.println(new InstanceInitializer(){
            {y = "a new value set by the child AFTER construction";}

This outputs (something like):

Enter a number: 1
Enter a string: a
The value of x is 1
The value of y is aaaaaaaa
Enter a number: q
Enter a string: r
The value of x is 0
The value of y is rrrrrrrr

Enter a number: 3
Enter a string: b
The value of x is 3
The value of y is bbbbbbbb
a new value set by the child AFTER construction
Enter a number: s
Enter a string: Hello
The value of x is 0
The value of y is HelloHelloHelloHelloHelloHelloHelloHello 
a new value set by the child AFTER construction

Notice that the "new value" string is not set until after the parent class's constructor has already been called.