Quando viene inizializzata un'interfaccia con un metodo predefinito?

Durante la ricerca attraverso il linguaggio Java Specification per rispondere a questa domanda , ho imparato che

Prima che una classe venga inizializzata, la sua superclasse diretta deve essere inizializzata, ma le interfacce implementate dalla classe non vengono inizializzate. Allo stesso modo, le superinterfacce di un'interfaccia non vengono inizializzate prima che l'interfaccia sia inizializzata.

Per mia curiosità, l'ho provato e, come previsto, l'interfaccia InterfaceTypenon è stata inizializzata.

public class Example {
    public static void main(String[] args) throws Exception {
        InterfaceType foo = new InterfaceTypeImpl();
        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();
}

Questo programma stampa

implemented method

Tuttavia, se l'interfaccia dichiara un defaultmetodo, viene eseguita l'inizializzazione. Considera l' InterfaceTypeinterfaccia data come

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

    public default void method() {
        System.out.println("default method");
    }
}

quindi lo stesso programma sopra verrà stampato

static initializer  
implemented method

In altre parole, il staticcampo dell'interfaccia viene inizializzato ( passaggio 9 nella procedura di inizializzazione dettagliata ) e staticviene eseguito l' inizializzatore del tipo da inizializzare. Ciò significa che l'interfaccia è stata inizializzata.

Non sono riuscito a trovare nulla nel JLS per indicare che ciò dovrebbe accadere. Non fraintendetemi, capisco che ciò dovrebbe accadere nel caso in cui la classe di implementazione non fornisca un'implementazione per il metodo, ma cosa succede se lo fa? Questa condizione manca nelle specifiche del linguaggio Java, mi sono perso qualcosa o lo sto interpretando in modo errato?

Questa è una questione molto interessante!

Sembra che la sezione 12.4.1 di JLS dovrebbe coprirlo definitivamente. Tuttavia, il comportamento di Oracle JDK e OpenJDK (javac e HotSpot) è diverso da quanto specificato qui. In particolare, l'Esempio 12.4.1-3 di questa sezione copre l'inizializzazione dell'interfaccia. L'esempio come segue:

interface I {
    int i = 1, ii = Test.out("ii", 2);
}
interface J extends I {
    int j = Test.out("j", 3), jj = Test.out("jj", 4);
}
interface K extends J {
    int k = Test.out("k", 5);
}
class Test {
    public static void main(String[] args) {
        System.out.println(J.i);
        System.out.println(K.j);
    }
    static int out(String s, int i) {
        System.out.println(s + "=" + i);
        return i;
    }
}

Il suo output previsto è:

1
j=3
jj=4
3

e infatti ottengo l'output atteso. Tuttavia, se viene aggiunto un metodo predefinito all'interfaccia I,

interface I {
    int i = 1, ii = Test.out("ii", 2);
    default void method() { } // causes initialization!
}

l'output cambia in:

1
ii=2
j=3
jj=4
3

che indica chiaramente che l'interfaccia Iviene inizializzata dove non era prima! La semplice presenza del metodo di default è sufficiente per attivare l'inizializzazione. Il metodo predefinito non deve essere chiamato, sovrascritto o nemmeno menzionato, né la presenza di un metodo astratto attiva l'inizializzazione.

La mia ipotesi è che l'implementazione di HotSpot volesse evitare di aggiungere l'inizializzazione di classe / interfaccia nel percorso critico della invokevirtualchiamata. Prima di Java 8 e dei metodi predefiniti, invokevirtualnon poteva mai finire per eseguire codice in un'interfaccia, quindi questo non si verificava. Si potrebbe pensare che questo faccia parte della fase di preparazione della classe / interfaccia ( JLS 12.3.2 ) che inizializza cose come le tabelle dei metodi. Ma forse questo è andato troppo oltre e accidentalmente ha invece eseguito l'inizializzazione completa.

Ho sollevato questa domanda nella mailing list OpenJDK compilatore-dev. C'è stata una risposta da Alex Buckley (editore di JLS) in cui solleva ulteriori domande rivolte alla JVM e ai team di implementazione lambda. Nota anche che c'è un bug nelle specifiche qui dove si dice che "T è una classe e viene invocato un metodo statico dichiarato da T" dovrebbe applicarsi anche se T è un'interfaccia. Quindi, potrebbe essere che qui ci siano sia specifiche che bug HotSpot.

Divulgazione : lavoro per Oracle su OpenJDK. Se la gente pensa che questo mi dia un vantaggio ingiusto nell'ottenere la taglia associata a questa domanda, sono disposto a essere flessibile al riguardo.

L'interfaccia non è inizializzata perché il campo della costante InterfaceType.init, che viene inizializzato da un valore non costante (chiamata al metodo), non viene utilizzato da nessuna parte.

È noto in fase di compilazione che il campo costante dell'interfaccia non viene utilizzato da nessuna parte e l'interfaccia non contiene alcun metodo predefinito (in java-8), quindi non è necessario inizializzare o caricare l'interfaccia.

L'interfaccia verrà inizializzata nei seguenti casi,

• il campo costante viene utilizzato nel codice.
• L'interfaccia contiene un metodo predefinito (Java 8)

In caso di metodi predefiniti , stai implementando InterfaceType. Quindi, se InterfaceTypeconterrà metodi predefiniti, sarà INHERITED (utilizzato) nella classe di implementazione. E l'inizializzazione sarà nell'immagine.

Tuttavia, se si accede al campo costante dell'interfaccia (che viene inizializzato in modo normale), l'inizializzazione dell'interfaccia non è richiesta.

Considera il seguente codice.

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();
}

Nel caso precedente, l'interfaccia verrà inizializzata e caricata perché stai utilizzando il campo InterfaceType.init.

Non sto fornendo l'esempio del metodo predefinito poiché lo hai già indicato nella tua domanda.

La specifica del linguaggio Java e l'esempio sono forniti in JLS 12.4.1 (l'esempio non contiene metodi predefiniti).

Non riesco a trovare JLS per i metodi predefiniti, potrebbero esserci due possibilità

• Le persone Java hanno dimenticato di considerare il caso del metodo predefinito. (Specification Doc bug.)
• Fanno semplicemente riferimento ai metodi predefiniti come membri non costanti dell'interfaccia. (Ma non menzionato da nessuna parte, ancora una volta il bug del documento delle specifiche.)

Il file instanceKlass.cpp da OpenJDK contiene il metodo di inizializzazione InstanceKlass::initialize_implche corrisponde alla procedura di inizializzazione dettagliata in JLS, che si trova analogamente nella sezione Inizializzazione nella specifica JVM.

Contiene un nuovo passaggio che non è menzionato nel JLS e non nel libro JVM a cui si fa riferimento nel codice:

// 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);
    ....
    }
  }
}

Quindi questa inizializzazione è stata implementata esplicitamente come nuovo passaggio 7.5 . Ciò indica che questa implementazione ha seguito alcune specifiche, ma sembra che le specifiche scritte sul sito Web non siano state aggiornate di conseguenza.

EDIT: come riferimento, il commit (da ottobre 2012!) In cui il rispettivo passaggio è stato incluso nell'implementazione: http://hg.openjdk.java.net/jdk8/build/hotspot/rev/4735d2c84362

EDIT2: Casualmente, ho trovato questo documento sui metodi predefiniti in hotspot che contiene una nota a margine interessante alla fine:

3.7 Varie

Poiché le interfacce ora contengono un bytecode, è necessario inizializzarle nel momento in cui viene inizializzata una classe di implementazione.

Cercherò di dimostrare che un'inizializzazione dell'interfaccia non dovrebbe causare effetti collaterali del canale laterale da cui dipendono i sottotipi, quindi, indipendentemente dal fatto che si tratti di un bug o meno, o in qualunque modo Java lo risolva, non dovrebbe importare l'applicazione in cui vengono inizializzate le interfacce dell'ordine.

Nel caso di a class, è ben accettato che possa causare effetti collaterali da cui dipendono le sottoclassi. Per esempio

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

Qualsiasi sottoclasse di Foosi aspetterebbe di vedere $ 1000 in banca, ovunque nel codice della sottoclasse. Pertanto la superclasse viene inizializzata prima della sottoclasse.

Non dovremmo fare la stessa cosa anche per le superintefaccia? Sfortunatamente, l'ordine delle superinterfacce non dovrebbe essere significativo, quindi non esiste un ordine ben definito in cui inizializzarle.

Quindi è meglio non stabilire questo tipo di effetti collaterali nelle inizializzazioni dell'interfaccia. Dopotutto, interfacenon è pensato per queste funzionalità (campi / metodi statici) che accumuliamo per comodità.

Pertanto, se seguiamo questo principio, non ci preoccuperemo in quale ordine vengono inizializzate le interfacce.