What is the use of non-static block in java?

Question

Possible Duplicate:
How is an instance initializer different from a constructor?

When all the required work can be done inside the constructor, then why do we still need non-static block in Java?

EDIT: What about normal classes for which non-static blocks run everytime before the constructor?

Answer 1

In additional to @Bohemian's answer.

If you have multiple constructors an intialiser block avoid duplication.

public class A {
     final Map<String, String> map = new HashMap<String, String>(); {
        // put things in map.
     }
     final int number; {
        int number;
        try {
            number = throwsAnException();
        } catch (Exception e) {
            number = 5;
        }
        this.number = number;
     }

     public A() { /* constructor 1 */ }
     public A(int i) { /* constructor 2 */ }
}

What about normal classes for which non-static blocks run everytime before the constructor?

Technically the order is

• the super constructor is always called first
• all the initializer blocks in order of appearence.
• the constructor code

In reality all this code is in the byte code for each constructor so there is nothing before or after the constructor at runtime.

---

Before there is any more confusion as to the order of initialization

public class Main extends SuperClass {
    {
        System.out.println("Initialiser block before constructor");
    }

    Main() {
        System.out.println("Main constructor");
    }

    {
        System.out.println("Initialiser block after constructor");

    }

    public static void main(String... args) {
        new Main() {{
            System.out.println("Anonymous initalizer block");
        }};
    }
}

class SuperClass {
    SuperClass() {
        System.out.println("SuperClass constructor");
    }
}

prints

SuperClass constructor
Initialiser block before constructor
Initialiser block after constructor
Main constructor
Anonymous initalizer block

Answer 2

You can use it with an anonymous class:

new MyClass() {
    {
         // do something extra on construction (after the constructor executes)
    }
}

I find this is particularly useful for initializing "look up" maps (ie fixed contents) in place:

Map<String, String> map = new HashMap<String, String>() {
    {
        put("foo", "bar");
        put("one", "two");
        // etc
    }
};

FYI, this is sometimes (poorly) called "double brace initialization", when in fact it's simply employing an initializer block.

Although such an anonymous class is technically a subclass, the beauty of this is shown when comparing using this technique with a more traditional one in creating an unmodifiable map:

Compare this straightforward one-liner, which places data and assignment together:

private static final Map<String, String> map = Collections.unmodifiableMap(
    new HashMap<String, String>() {{
        put("foo", "bar");
        put("one", "two");
        // etc
    }});

With this mess, which must create a separate object due to final only allowing one assignment:

private static final Map<String, String> map;

static {
    Map<String, String> tempMap = new HashMap<String, String>();
    tempMap.put("foo", "bar");
    tempMap.put("one", "two");
    // etc
    map = Collections.unmodifiableMap(tempMap);
}

Also note that with the mess version, the two statements need not be adjacent, so it can become less obvious what the contents of the unmodifiable map is.