Perché il metodo di chiamata con ritorno generico su una classe generica è considerato non sicuro da javac?

Question

Si consideri il seguente codice:

public class Main { 
    public static class NormalClass { 
     public Class<Integer> method() { 
      return Integer.class; 
     } 
    } 

    public static class GenericClass<T> { 
     public Class<Integer> method() { 
      return Integer.class; 
     } 
    } 

    public static void main(String... args) { 
     NormalClass safeInstance = new NormalClass(); 
     Class<Integer> safeValue = safeInstance.method(); 

     GenericClass unsafeInstance = new GenericClass(); 
     Class<Integer> unsafeValue = unsafeInstance.method(); 
    } 
} 

Se compilo con:

$ javac -Xlint:unchecked Main.java 

Restituisce:

Main.java:16: warning: [unchecked] unchecked conversion 
     Class<Integer> unsafeValue = unsafeInstance.method(); 
                 ^
    required: Class<Integer> 
    found: Class 
1 warning 

Si prega di notare che solo il metodo generico è considerato pericoloso, anche se nessun tipo generico è referenziato sul tipo di reso.

È un errore javac? O c'è una ragione più profonda per questo che non sto prendendo in considerazione?

Answer 1

I tipi non elaborati consentivano la compatibilità con il codice scritto prima dell'introduzione dei generici. I tipi non elaborati funzionano semplicemente ignorando tutte le informazioni sul tipo da tutti gli argomenti del metodo e i tipi restituiti, anche digitando informazioni che non sono correlate al parametro type della classe. Questo può portare a risultati strani, come hai trovato. Ma diventa ancora più strano di questo. Ad esempio, questo compila.

public class Main { 

    public static class GenericClass<T> { 
     public void foo(Class<Integer> clazz) { 
     } 
    } 

    public static void main(String... args) { 
     GenericClass unsafeInstance = new GenericClass(); 
     unsafeInstance.foo(String.class); 
    } 
} 

Answer 2

Al fine di essere compatibile con Java 1.4 del compilatore presuppone che se si lascia cadere gli argomenti generici sulla dichiarazione del tipo di esempio, poi si lavora con la versione speciale della classe dove non esistono affatto generici. E emette un avviso se si mescola un codice Java non generico 1.4 con codice generico Java 1.5+. È più facile che cercare di capire se il tipo generico di restituzione del tuo metodo sia effettivamente indipendente dai parametri. Puoi sempre @SuppressWarning se non ti piace.

Answer 3

Il tipo di un costruttore (§8.8), metodo di istanza (§8.4, §9.4), o non statico campo (§8.3) M di tipo C grezza che non viene ereditato dalle sue superclassi o superinterfacce è il tipo di greggio che corrisponde alla cancellazione del suo tipo nella dichiarazione generico corrispondente al C.

Java Language Specification

Answer 4

Questo può avere a che fare con l'istanza di GenericClass che è un tipo parametrizzato e quindi digitare argomenti sono necessari in esso. L'avvertimento scompare se facciamo qualcosa di simile al seguente

GenericClass<String> unsafeInstance = new GenericClass<String>(); 
          OR 
GenericClass<?> unsafeInstance = new GenericClass(); 

Secondo il mio punto di vista, il riferimento "unsafeInstance" si riferisce a una classe che è di natura generica al contrario di "safeInstance". In questo modo il compilatore può volere che le informazioni sul tipo siano associate al riferimento prima che qualsiasi metodo venga chiamato utilizzandolo nel codice.