¿Cuándo se inicializa una interfaz con un método predeterminado?

La interfaz no se inicializa porque el campo constante InterfaceType.init , que se inicializa mediante un valor no constante (llamada al método), no se utiliza en ninguna parte.

Se sabe en tiempo de compilación que el campo constante de la interfaz no se usa en ninguna parte, y la interfaz no contiene ningún método predeterminado (en java-8), por lo que no hay necesidad de inicializar o cargar la interfaz.

La interfaz se inicializará en los siguientes casos,

• el campo constante se usa en su código.
• La interfaz contiene un método predeterminado (Java 8)

En el caso de Métodos predeterminados, Está implementando InterfaceType. Por lo tanto, si InterfaceType contendrá cualquier método predeterminado, será HEREDADO (utilizado) en la clase de implementación. Y la inicialización estará en la imagen.

Pero, si está accediendo al campo constante de la interfaz (que se inicializa de manera normal), la inicialización de la interfaz no es necesaria.

Considere seguir codificar.

public class Example {
    public static void main(String[] args) throws Exception {
        InterfaceType foo = new InterfaceTypeImpl();
        System.out.println(InterfaceType.init);
        foo.method();
    }
}

class InterfaceTypeImpl implements InterfaceType {
    @Override
    public void method() {
        System.out.println("implemented method");
    }
}

class ClassInitializer {
    static {
        System.out.println("static initializer");
    }
}

interface InterfaceType {
    public static final ClassInitializer init = new ClassInitializer();

    public void method();
}

En el caso anterior, la interfaz se inicializará y cargará porque está utilizando el campo InterfaceType.init.

No estoy dando el ejemplo del método predeterminado como ya lo dio en su pregunta.

La especificación del lenguaje Java y el ejemplo se dan en JLS 12.4.1 (El ejemplo no contiene métodos predeterminados.)

No puedo encontrar JLS para los métodos predeterminados, puede haber dos posibilidades

• La gente de Java olvidó considerar el caso del método por defecto. (Especificación Doc bug.)
• Simplemente se refieren a los métodos predeterminados como miembros no constantes de interfaz. (Pero no mencionó donde, de nuevo Especificación Doc bug.)

El instanceKlass.el archivo cpp del OpenJDK contiene el método de inicialización InstanceKlass::initialize_implque corresponde al Procedimiento de Inicialización Detallado en el JLS, que se encuentra análogamente en la sección Inicialización en la especificación JVM.

Contiene un nuevo paso que no se menciona en el JLS y no en el libro JVM al que se hace referencia en el código:

// refer to the JVM book page 47 for description of steps
...

if (this_oop->has_default_methods()) {
  // Step 7.5: initialize any interfaces which have default methods
  for (int i = 0; i < this_oop->local_interfaces()->length(); ++i) {
    Klass* iface = this_oop->local_interfaces()->at(i);
    InstanceKlass* ik = InstanceKlass::cast(iface);
    if (ik->has_default_methods() && ik->should_be_initialized()) {
      ik->initialize(THREAD);
    ....
    }
  }
}

Así que esta inicialización se ha implementado explícitamente como un nuevo Paso 7.5. Esto indica que esta implementación siguió alguna especificación, pero parece que la especificación escrita en el sitio web no se ha actualizado en consecuencia.

EDITAR: Como referencia, el commit (de octubre de 2012!) cuando la etapa respectiva se haya incluido en la aplicación: http://hg.openjdk.java.net/jdk8/build/hotspot/rev/4735d2c84362

EDIT2: Casualmente, encontré este Documento sobre métodos predeterminados en hotspot que contiene un interesante nota al final:

3.7 Varios

Debido a que las interfaces ahora tienen bytecode en ellas, debemos inicializarlas en el tiempo que se inicializa una clase de implementación.

Voy a tratar de hacer un caso de que una inicialización de interfaz no debe causar ningún efecto secundario de canal lateral que los subtipos dependen de, por lo tanto, si esto es un error o no, o de cualquier manera que Java lo arregle, no debe importar a la aplicación en qué orden se inicializan las interfaces.

En el caso de un class, es bien aceptado que puede causar efectos secundarios de los que dependen las subclases. Por ejemplo

class Foo{
    static{
        Bank.deposit($1000);
...

Cualquier subclase de Foo esperaría que vieran 1 1000 en el banco, en cualquier parte del código de la subclase. Por lo tanto, la superclase se inicializa antes de la subclase.

¿No deberíamos hacer lo mismo con superintefaces también? Desafortunadamente, el orden de las superinterfaces no se supone que sea significativo, por lo tanto no hay un orden bien definido en el que inicializarlas.

Así que es mejor no establecer este tipo de efectos secundarios en inicializaciones de interfaz. Después de todo, interface no está destinado a estas características (estática campos / métodos) nos apilamos para mayor comodidad.

Por lo tanto, si seguimos ese principio, no nos preocupará en qué orden se inicializan las interfaces.