Why do we use static blocks when we already have static methods?

Question

Why do we use static blocks when we can use static methods for initializing static variables? What difference does it make? What is the logic to this.

Answer 1

I assume you are referring to static initializer blocks?

static { ... }

Static initializer blocks and static methods are both required because they do different things.

Static initializer blocks are blocks for initializing the class. They are run exactly once, when the class is loaded. They don't return anything, and can't throw a checked exception because there is no way to declare throws.

In fact, a static field with an initializer:

static int a = 0;

Is actually converted to a field declaration and a static initializer block:

static int a;

static {
  a = 0;
}

You can assign zero or more static final variables in a static initializer, provided they have not already been assigned.

Static methods can be invoked at any time. They can return a value, and throw checked exceptions. You cannot assign static final variables in a static method (although you can assign non-final static variables).

Answer 2

You are thinking about very 2 different ideas about initialize object. for example:

class A {
   static Map<String, String> map;

   static {
      map = new HashMap<String, String>();
   }

   public static void initializeMap() {
       map = new HashMap<String, String>();
   }

   public static void insert(String key, String value) {
       map.put(key, value);
   }
}

If we use static initializer block, the very first time you use any static method (i.e: insert), it will run static block first. And by doing this, you are safe for concurrency control. i.e: there are multiple threads try to call method insert at very beginning, Java will only run initialize block once.

Using static method for initialize such as initializeMap in this case, the advantage is you move the control of when run init to your own program. Maybe your class should not init ASAP but only your program told to do so. Other advantage is you can control the return value, or raise exception if needed (you cannot raise exception in static initializer block).

Note that the static method above is not safe and should not call concurrently. Other word, you should make sure only one thread call that method for initialize map. Otherwise, you must add lock to control multiple thread access.

Some other notes about advantages of using static initializer block:

• Handle concurrency access automatically provided by Java.
• Some program we don't know exactly where to put static method, so using static initializer is a safe choice.
• Some complex initialize cannot be done in one line, so static initializer is the only choice.

Answer 3

You have static blocks to do more complex initialization, like for instance this upload queue where you just want to make sure a directory exists.

static {
    File f = new File(getUploadDir());
    if(!f.exists()) {
        //noinspection ResultOfMethodCallIgnored
        f.mkdir();
    }
}

You can also use it to set some properties on static objects. Here's an example:

private static final SimpleDateFormat mDateTimeFormat = new 
      SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);

static {
    mDateTimeFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
}