Initialization of Java - Class v/s Interface

I am stuck at the below concept of initialization of java class and interface :

I read the following sentence in the below mentioned book :

An interface is initialized only because a non-constant field declared by the interface is used, never because a subinterface or class that implements the interface needs to be initialized.

But that isn't the case when we initialise any java class.

Thus, initialization of a class requires prior initialization of all its superclasses, but not its superinterfaces.

Initialization of an interface does not require initialization of its superinterfaces.

My question is Why is this so ?

Any 开发者_如何学运维help would be greatly appreciated !

Thanks

PS : Book - "Inside the Java Virtual Machine" by Bill Venners (Chapter 7 - LifeTime of a class )

---

The only things you can declare in an interface are method signatures and constant fields. The latter can be initialized using constant values (i.e. string literals, integers, etc., possibly in some combination) or using non-constant values (i.e. method calls). Thus if an interface doesn't have any non-constant fields, no initialization is required -- everything is known at compile time. If there are non-constant fields that are used by the program, initialization code must be run to ensure those fields are assigned a value.

Hope that helps.

P.S.: That chapter is available online here if anyone wants to read it in full.

---

To cite the Java language specification §12.4.1:

A class or interface type T will be initialized immediately before the first occurrence of any one of the following:

• T is a class and an instance of T is created.
• T is a class and a static method declared by T is invoked.
• A static field declared by T is assigned.
• A static field declared by T is used and the reference to the field is not a compile-time constant (§15.28). References to compile-time constants must be resolved at compile time to a copy of the compile-time constant value, so uses of such a field never cause initialization.

Invocation of certain reflective methods in class Class and in package java.lang.reflect also causes class or interface initialization. A class or interface will not be initialized under any other circumstance.

The intent here is that a class or interface type has a set of initializers that put it in a consistent state, and that this state is the first state that is observed by other classes.

---

Interesting. Let's see why superclass must be initialized before subclass.

class A
    static x = DB.insert(1,...);
class B extends A
    static y = DB.select(1);

The static initializer of a superclass can cause some side effects that the compiler cannot see, and the subclass may depend on such side effects.

However the same argument can apply to super interfaces. I don't see a hard reason why Java doesn't initialize super interfaces eagerly. Soft reasons are anybody's guess.

Give the rules as they are, we must be careful with field initialization in interfaces:

1. better not have any fields in an interface
2. otherwise, fields better be compile time constant only
3. otherwise, field initialization better not have any side effect.
4. otherwise, side effect must be only accessible through the field itself