Esiste un modo pulito per assegnare la classe di un tipo generico a una variabile?

Question

Dato questo codice:

List<Integer> ints = new ArrayList<Integer>(); 

// Type mismatch: 
// cannot convert from Class<capture#1-of ? extends List> to Class<List<Integer>>  
Class<List<Integer>> typeTry1 = ints.getClass(); 

// Type safety: 
// Unchecked cast from Class<capture#2-of ? extends List> to Class<List<Integer>> 
Class<List<Integer>> typeTry2 = (Class<List<Integer>>) ints.getClass(); 

// List is a raw type. References to generic type List<E> should be parameterized 
Class<? extends List> typeTry3 = ints.getClass(); 

C'è un modo per ottenere il Class di un List<Integer> senza un errore o un avvertimento? Posso sopprimere gli avvertimenti abbastanza facilmente, ma se Java mi richiede di sopprimere un avviso per questo codice valido, sono molto disappoint.

D'altra parte, se la soppressione degli avvisi è l'unico modo, qual è il più sicuro da sopprimere?

Answer 1

Questo è un vero Catch-22 in Java.

Il compilatore avverte se non si aggiunge un tipo generico di List:

// WARN: List is not typed 
Class<? extends List> typeTry3 = ints.getClass(); 

Questo perché, nella maggior parte dei casi, è davvero meglio di digitare le vostre liste.

Tuttavia, a causa della cancellazione dei tipi, Java non è in grado di calcolare il tipo generico di List in fase di esecuzione e il compilatore lo sa. Pertanto, non v'è alcun metodo su Class che restituito un oggetto tipizzato:

// ERROR: ints.getClass() doesn't return a Class<List<Integer>>, it returns a Class<List> 
Class<? extends List<? extends Integer>> var = ints.getClass(); 

Così si deve cast a un elenco digitato. Tuttavia, come si sa, dal momento che non v'è alcun tipo di runtime controllo, Java avvisa di eventuali calchi a una variabile digitato:

// WARN: Casting to typed List 
Class<List<Integer>> typeTry2 = (Class<List<Integer>>) ints.getClass(); 

Qualsiasi tentativo per aggirare questo è essenzialmente un mezzo di confondere il compilatore, e inevitabilmente essere contorto.

La cosa migliore quindi è di andare con Opzione B:

D'altra parte, se la soppressione di avviso è l'unico modo, quello che è il più sicuro di sopprimere?

Il modo più sicuro per eliminare questo avviso è rendere l'annotazione @SuppressWarnings("unchecked") il più possibile localizzata. Mettili sopra ogni singolo cast non controllato. In questo modo è assolutamente chiaro chi sta causando l'avvertimento.

Answer 2

Un modo per farlo sarebbe creare il tuo own class. Non sono sicuro che questo soddisferà le tue esigenze.

Non sono proprio sicuro di cosa stai cercando di ottenere. Quindi forse wildcards è la risposta.

import java.util.*; 

class Main 
{ 
     public static void main(String[] args) 
     { 
      List<Integer> list = new ArrayList<Integer>(); 
      Class<?> clazz = list.getClass(); 
      System.out.println(clazz) ; 
     } 
}