Casting per una classe interna con i generici

Question

Si consideri il seguente codice:

public class Outer<T> { 

    public class Inner{ 
    } 

    public static <T> Outer<T>.Inner get(){ 
     Object o = new Object(); 
     return (Outer<T>.Inner)o; 
    } 

    public static void main(String[] args) throws Exception { 
     Outer.<String>get(); 
    } 
} 

Questo codice viene compilato con successo in Eclipse, ma non riesce a compilare in javac:

Outer.java:10: ')' expected 
     return (Outer<T>.Inner)o; 
         ^
Outer.java:10: ';' expected 
     return (Outer<T>.Inner)o; 
         ^
Outer.java:10: illegal start of expression 
     return (Outer<T>.Inner)o; 
          ^
3 errors 

È questo un bug in javac o Eclisse?

Se cambio il cast per (Outer.Inner)o si compila, anche se c'è un avvertimento:

Eclipse:

Outer.Inner is a raw type. References to generic type Outer<T>.Inner should be parameterized 

javac:

Outer.java:10: warning: [unchecked] unchecked conversion 
found : Outer.Inner 
required: Outer<T>.Inner 
     return (Outer.Inner)o; 
      ^
1 warning 

Javac versione: 1.6.0_21

Answer 1

Ho trovato che questo è un bug nel compilatore javac che è stato corretto. JDK 7b100 compila questa multa.

Vedere http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6665356

Answer 2

You cann o lancia un Object a qualcosa che non è.

Answer 3

Purtroppo, se si sta trasmettendo da uno Object, non è possibile evitare l'avviso di cast non controllato. Questo perché Object non ha abbastanza informazioni di tipo da solo per avere lo T.

(generici Java sono la cancellazione-based. Pertanto non v'è alcun modo di sapere se un oggetto ha tipo di argomento T in fase di esecuzione --- argomenti di tipo vengono utilizzati al solo tempo di compilazione.)

Answer 4

Il seguente "sistemare "ha funzionato quando ho compilato con javac. Inoltre è stato compilato con successo in Eclipse. Il problema che percepisco è che non puoi creare un nuovo oggetto da una variabile (come quello che hai fatto nel tuo caso). Non so come spiegarlo o convalidare la mia teoria.

/** 
* 
*/ 
package testcases; 

/** 
* @author The Elite Gentleman 
* 
*/ 
public class Outer<T> { 

    public class Inner{ 
    } 

    public static <T> Outer<T>.Inner get(){ 
     //Object o = new Object(); 
     //return (Outer<T>.Inner)o; 
     return new Outer<T>().new Inner(); 
    } 

    public static void main(String[] args) throws Exception { 
     Outer.<String>get(); 
    } 
} 

In sostanza, dal momento interno non è una classe innestata statica, al fine di creare un'istanza di esso, questo è come si dovrebbe farlo:

new Outer<T>().new Inner(); 

Inoltre, Object o = new Object(); non garantisce che l'oggetto o è in realtà un'istanza di tipo Inner classe.

---

Aggiornamento La mia soluzione ha aiutato con instantiation oggetto e non per oggetto colata di esistenti un'istanza dell'oggetto. Per questo, non ho risposte (ma siamo sviluppatori, penseremo a qualcosa :-)).

Quello che posso pensare è perché non rendere la classe nidificata statica classe Inner?

Answer 5

ci sono due problemi in voi codice:

Il primo è in fase di compilazione: non si può lanciare in modo sicuro un oggetto a un tipo generico come i generici non sono reificati in Java. Il lancio su un generico non istanziato è chiaramente pericoloso per il tuo javac. Temo che la risposta del compilatore a questo dipende dal produttore del compilatore e dalla versione.

In secondo luogo, lanciando un oggetto, di tipo Oggetto, a qualsiasi altro tipo si genera un ClassCastException in fase di esecuzione come in Java le informazioni sul tipo sono contenute nell'oggetto e non cambieranno dopo la creazione.

Answer 6

se è necessario utilizzare un cast, è possibile eliminare l'avviso con @SuppressWarnings

Object o = new Object(); 

    @SuppressWarnings("unchecked") 
    Outer<T>.Inner returnVal = (Outer.Inner) o; 

    return returnVal; 

Ma realizzare esiste l'avviso perché si sta facendo qualcosa di pericoloso. L'oggetto non può essere trasmesso a String. Ciò provocherà un'eccezione in fase di runtime.

E come The Gentleman Elite notato, si consiglia di contrassegnare interno come statica:

public static class Inner { 

Answer 7

La cosa più divertente è che, a meno che non ci sia qualcosa che mi manca di generici Java, sia

return (Outer<T>.Inner) o; 

E

return (Outer.Inner) o; 

Sia compilare lo stesso bytecode.

Il problema per la prima riga si verifica durante l'analisi, ovvero javac ed Eclipse non utilizzano lo stesso parser per il codice sorgente Java. Dovresti fare una domanda su quali differenze ci siano tra java parser e javac di Eclipse JDT. (O pubblica un bug su Eclipse).

Se ti ostini a mantenere quel comportamento (vorrei suggerire refactoring Inner ad una classe interna statica), è possibile utilizzare @SuppressWarning con un'assegnazione di campo (al fine di limitare il @SuppressWarning al più piccolo campo di applicazione possibile).

@SuppressWarnings({"rawtypes","unchecked"}) 
Outer<T>.Inner casted = (Outer.Inner)o; 
return casted; 

EDIT: OK, credo ho preso - JDT di Eclipse analizza il codice Java prima di passarlo al compilatore - e il loro parser in grado di dare un senso a un cast, mentre (almeno il vostro e il mio versione di) javac non può. (E dopo questo, Eclipse passa direttamente il codice analizzato alla compilazione). Prima di presentare un bug, guarda come si comporta l'ultima versione di Java 6.

Answer 8

(Dare un'altra risposta perché la mia precedente è troppo rumoroso.)

Ci sono due grandi passi da fare al fine di compilare il codice sorgente Java in bytecode:

1. Il codice sorgente deve essere analizzato in un albero di sintassi.
2. L'albero di sintassi viene utilizzato per generate bytecode.

Quando javac compila, utilizza il proprio parser e generatore di codice (i cui dettagli di implementazione dipendono dal JDK che si sta utilizzando).

Quando JDT di Eclipse viene compilato, utilizza il proprio parser di codice e dopo questo ... Non lo so. Il punto che voglio fare è che, in un modo o nell'altro, "bypassano" alcuni dei parser di javac. (Ad esempio, potrebbero passare a file java modificati javac che sostituiscono tutti i cast di classi generiche con le classi raw).

Il mio punto è - alla fine, è un bug nella parte di javac che analizza il codice sorgente java. (Non vi è alcun motivo per cui un tale costrutto non sia consentito nelle specifiche del linguaggio.)

Per ovviare a tale errore, è possibile: * Modificare il progetto dell'applicazione per evitarlo completamente. * Ogni volta che devi fare questo cast, tutti mettono un tipo grezzo e un'annotazione @SuppressWarnings invece del cast naturale.