Java: getClass() del tipo limitato

Question

Ho notato qualcosa mentre stavo scherzando con i generici. Nell'esempio che segue, doStuff1 compila ma doStuff2 non lo fa:

public <T extends Foo> void doStuff1(T value) { 
    Class<? extends Foo> theClass = value.getClass(); 
} 

public <T extends Foo> void doStuff2(T value) { 
    Class<? extends T> theClass = value.getClass(); 
} 

Così, ho guardato la documentazione per Object.getClass() e abbiamo trovato questo:

Il tipo di risultato effettivo è di classe <? estende | X | > dove | X | è la cancellazione del tipo statico dell'espressione su cui viene chiamato getClass.

Questo mi ha reso un po 'curioso. Perché lo getClass() è progettato in questo modo? Riesco a capire i tipi di conversione nelle loro classi raw, se applicabili, ma non vedo ragioni ovvie perché debbano necessariamente farlo uccidere anche T. Esiste una ragione specifica per cui si sbarazza anche di questo, o è solo un approccio generale "liberiamoci di tutto solo perché è più facile, chi avrebbe mai bisogno comunque"?

Answer 1

Se getClass() restituisce Class<? extends X>, non può accadere nulla di veramente brutto;

L'unico problema è che non è teoricamente corretto: se un oggetto è un ArrayList<String>, il suo class non può essere Class<ArrayList<String>> - non esiste una tale classe, c'è solo un Class<ArrayList>.

Questo in realtà non è correlato alla cancellazione. Se un giorno Java ottiene i tipi pieni reificati, getClass() deve ancora restituire Class<? extends |X|>; tuttavia, dovrebbe esserci un nuovo metodo, ad esempio getType() che può restituire un valore più dettagliato Type<? extends X>. (Anche se, getType può entrare in conflitto con un sacco di classi esistenti con i propri getType metodi)

Per l'essere tempistica, dal momento che Class<? extends X> potrebbe essere utile in molti casi, siamo in grado di progettare il nostro proprio metodo che lo fa

static <X> Class<? extends X> myGetClass(X x){ ... } 

ma è comprensibile che non avrebbero messo questo tipo di hack in lib standard.

Answer 2

Non si può essere sicuri che value è in realtà un T, potrebbe anche essere una sottoclasse di T. getClass() fa tornare la classe "reale" di value, ma non si può essere sicuri che sia T, therfore deve leggere Class<? extends T>! Questo non ha nulla a che fare con il fatto che T è un parametro di tipo.

[Modifica] Ok, non proprio, non mi sono reso conto che method2 non viene compilato. Penso che questo sia un problema del compilatore. Ottengo

Type mismatch: cannot convert from Class<capture#1-of ? extends Foo> to Class<? extends T> 

Penso che il compilatore si accorga solo che l'oggetto T è un Foo. Il compilatore dovrebbe sapere che getClass() restituisce un po 'di Class<? extends T> ma sembra solo sapere che restituisce alcuni Class<? extends Foo>. Significa che Foo è lo erasure of the static type di T?