Sui metodi polimorfici di firma in Java-7

Question

Per quanto posso dire, con l'introduzione di MethodHandle in Java 7 è arrivata l'introduzione degli overload dei metodi generati dal compilatore.

I javadoc for MethodHandle stati (ho rifilato gli esempi):

Ecco alcuni esempi di utilizzo:

Object x, y; String s; int i; 
mh = ... 
// (Ljava/lang/String;CC)Ljava/lang/String; 
// (String, char, char) -> String 
s = (String) mh.invokeExact("daddy",'d','n'); 

// (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; 
// (Object, Object, Object) -> Object 
x = mh.invokeExact((Object)1, (Object)2, (Object)3); 

// (Ljava/util/List;)I 
// (List) -> int 
i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3)); 

// (Ljava/io/PrintStream;Ljava/lang/String;)V 
// (PrintStream, String) -> void 
mh.invokeExact(System.out, "Hello, world."); 

Ognuna delle chiamate di cui sopra genera una singola istruzione invokevirtual con il nome invocare e i descrittori di tipi indicati nei commenti . I tipi di argomento vengono presi direttamente dagli argomenti effettivi di , mentre il tipo di ritorno viene preso dal cast immediatamente applicato alla chiamata. Questo cast potrebbe essere di un primitivo. Se è mancante, il tipo viene impostato su Oggetto se la chiamata si verifica in un contesto che utilizza il valore restituito. Se la chiamata si verifica come una dichiarazione, un cast è impossibile e non esiste un tipo restituito; la chiamata è nulla.

In effetti, invokeExact e gli amici si comportano come se ci fosse un sovraccarico per ogni possibile combinazione di parametri e tipo di ritorno.

Ho sentito che MethodHandles si sta preparando per le funzionalità in Java 8 come lambda. (So ​​che sono già utili per linguaggi di scripting.)

[/ introduzione]

così, ci sono più di questi sovraccarichi generati dal compilatore che si nascondono intorno a Java? Ci sono indizi ce ne saranno di più in futuro (ad esempio con i metodi di estensione)? Perché è necessario in primo luogo? Semplicemente veloce? Come può aiutare Lambdas ( Ho pensato che Lambdas avrebbe compilato una classe interna anonima )?

In breve, qual è il fondamento logico; perché sono (sovraccarichi generati) utili ora e in futuro?

UPDATE: Quello che io chiamo generati dal compilatore sovraccarichi qui, i ragazzi Oracle Call firma polimorfi.

Answer 1

Ho appena imbattuto in un interni wiki Hotspot su MethodHandles and invokedynamic

Rende alcuni punti interessanti che rispondere a queste domande (e un po 'di più).

• Quello che viene chiamato sovraccarichi generati dal compilatore nella questione, i ragazzi chiamano java firma polimorfico.
• MethodHandle.invokeExact e gli amici sono unici, essendo gli unici metodi polimorfici di firma.
• Nella macchina virtuale HotSpot, il codice byte invokevirtual per MethodHandle.invoke * viene convertito segretamente in un'istruzione invokehandle.
  • invokehandle è come invokedynamic; alcuni interni sono diversi e in cui ogni istruzione invokedynamic deve puntare al proprio CPACE (Constant Pool Cache Entry), i numeri invokehandle possono condividere CPCE.
• invokedynamic utilizza il non pubblico MethodHandle.invokeBasic sul HotSpot VM
  • MethodHandle.invokeBasic è come invokeExact ma più sciolto; per uno non controlla i tipi di al sito di chiamata con quelli del callee.
• metodo maniglie calda (compresi invokedynamic) possono essere JIT-compilato

Inoltre, espressioni lambda sarà implemented via invokedynamic. (Got che dalla risposta di Edwin Dalorzo.) Ciò significa Espressioni lambda

• sarà indirettamente utilizzare MethodHandle.invokeBasic sul HotSpot VM (vedi sopra), e
• sono idonei a essere JIT-compilato

Answer 2

Questi due collegamenti non possono rispondere a tutte le vostre domande, ma potrebbero essere un buon punto di partenza:

• Translation of Lambda Expressions
• From Lambdas to Bytecode

Si tratta di materiale di riferimento ritornassi dal gruppo di esperti attualmente lavorando nel JDK 8: Project Lambda. Con un po 'di fortuna puoi trovare alcune spiegazioni, soprattutto sulla tua idea sbagliata di espressioni lambda come classi interne.