È una buona pratica di sostituire classe con la classe per evitare gli avvisi?

Question

In un gruppo o' posti nel mio codice, ho qualcosa di simile a questo:

public Class mySpecialMethod() {
  return MySpecialClass.class;
}

che fa sì che l'avviso

  

Class è un tipo grezzo. I riferimenti a   tipo generico di classe dovrebbe essere   parametrizzata.

Ma, se sostituisco

Class

con

Class<? extends Object>

l'avvertimento va via.

E 'questa semplice pratica ok, o potrebbe causare problemi in seguito?

Answer 1

E 'la cosa giusta da fare solo se c'è davvero nessuna classe base comune o interfaccia che l'oggetto di classe deve rappresentare.

Inoltre Class<?> è effettivamente la stessa Class<? extends Object>.

Answer 2

Sì, è del tutto giusto.

E 'un requisito che di specificare il tipo. E se non è possibile, è necessario specificare il jolly.

Per ulteriori approfondimenti: linguaggio Java Specification: Tipi con parametri

Answer 3

A seconda di ciò che si vuole raggiungere, si può essere ancora più preciso:

public Class<MySpecialClass> mySpecialMethod() {
  return MySpecialClass.class;
}

Answer 4

Non proprio un programmatore Java qui, ma leggere alcuni buoni articoli sulla farmaci generici.

Sì, si dovrebbe aggiungere un po 'jolly o il tipo esatto (Class<MySpecialClass>) per aggiungere la sicurezza. La ragione è che Class è un generico. Così, Class<Bar> e Class<Foo> sono lo stesso dopo la cancellazione del loro parametro di tipo generico. Tutti diventano Class, il tipo grezzo cosiddetto. Che la cancellazione avviene durante la compilazione. Alcuni esempi per illustrare questo in cui il compilatore ti aiuta con fusione automatica (Gestione delle eccezioni omesso per brevità):

class Mine { }

class Vara {
    public static void main(String... args) {
        { // works. translated to Mine m = (Mine) c.newInstance();
            Class<Mine> c = Mine.class;
            Mine m = c.newInstance();
        }
        { // doesn't work. need a cast: Mine m = (Mine) c.newInstance();
            Class c = Mine.class; // also Class<?> or Class<? extends Object>
            Object o = c.newInstance(); // but this works. pointing to a Mine
            Mine m = (Mine) c.newInstance(); // needs a manual cast
        }
    }
}

Dire Class<?> (e l'equivalente Class<? extends Object>), è dire al compilatore che si voleva davvero una classe i cui T è oggetto, e non ha utilizzato accidentalmente il tipo grezzo. Ma non aggiungere qualsiasi calchi di convenienza. Tutto ciò che fanno è farmaci generici per inserire calchi automatici per voi, per lanciare dal Object al tipo di destinazione. Generici sono gli stessi sia utilizzato con il tipo U o di tipo T in fase di esecuzione per motivi di compatibilità con le versioni java vecchie.