Java：静态初始化

Question

can you explain me which is the difference between:

public class Test {

    public static final Person p;

    static {
        p = new Person();
        p.setName("Josh");
    }

}

and

public class Test {

    public static final Person p = initPerson();

    private static Person initPerson() {
        Person p = new Person();
        p.setName("Josh");
        return p;
    }

}

I have always used the second one, but is there any difference with an static initializer block?

Answer 1

There are of course technical differences (you could invoke the static method multiple times within your class if you wanted, you could invoke it via reflection, etc) but, assuming you don't do any of that trickery, you're right -- the two approaches are effectively identical.

I also prefer the method-based approach, since it gives a nice name to the block of code. But it's almost entirely a stylistic approach.

As Marko points out, the method-based approach also serves to separate the two concerns of creating the Person, and assigning it to the static variable. With the static block, those two things are combined, which can hurt readability if the block is non-trivial. But with the method approach, the method is responsible solely for creating the object, and the static variable's initializion is responsible solely for taking that method's result and assigning it to the variable.

Taking this a bit further: if I have two static fields, and one depends on the other, then I'll declare two methods, and have the second method take the first variable as an explicit argument. I like to keep my static initialization methods entirely free of state, which makes it much easier to reason about which one should happen when (and what variables it assumes have already been created).

So, something like:

public class Test {
    public static final Person p = initPerson();
    public static final String pAddress = lookupAddress(p);

    /* implementations of initPerson and lookupAddress omitted */
}

It's very clear from looking at that, that (a) you don't need pAddress to initialize p , and (b) you do need p to initialize lookupAddress . In fact, the compiler would give you a compilation error ("illegal forward reference") if you tried them in reverse order and your static fields were non- final :

public static String pAddress = lookupAddress(p); // ERROR
public static Person p = initPerson();

You would lose that clarity and safety with static blocks. This compiles just fine:

static {
    pAddress = p.findAddressSomehow();
    p = new Person();
}

... but it'll fail at run time, since at p.findAddressSomehow() , p has its default value of null .

Answer 2

A static method (second example) is executed every time you call it. A static init block (first example) is only called once on initializing the class.

http://docs.oracle.com/javase/tutorial/java/javaOO/initial.html

The advantage of private static methods is that they can be reused later if you need to reinitialize the class variable.

This does not count for final instances, because a final variable can only be initialized once.

Answer 3

initPerson需要在某个时刻调用，而静态块在创建Test对象时执行。

Answer 4

The static before a function specifies that you can use that function by calling it on the Class name handle itself. For example, if you want to create a Person object outside the class you can write

Person p = Test.initPerson(); 

However, there is no advantageous difference between the two as you can access the object p outside the class in both cases.