Il mio tipo di codice è sicuro?

Question

Sono abbastanza sicuro che questo è sicuro, ma volevo solo verificare come Eclipse mi stia chiedendo di inserire un'annotazione @SuppressWarnings("unchecked").

Map<String, IFace> faces; 

public <T extends IFace> T getFace(String key) 
{ 
    return (T) faces.get(key); 
} 

Answer 1

Non è sicuro. Stai trasmettendo qui in modo che se passi a una classe derivata incompatibile ti imbatterai in un errore ad un certo punto.

Ad esempio se A_Face e B_Face entrambi estendono IFace. A un certo punto potresti lanciare un B_Face come A_Face che non è sicuro da testo.

Answer 2

Guarda il caso estremo. Diciamo IFace è acutally Object, il codice sia poi così:

static Map<String, Object> myMap = new HashMap<>(); 

public static void main(String[] args) throws Exception { 
    myMap.put("ONE", 1); 
    myMap.put("TWO", "TWO"); 
    myMap.put("THREE", new Date()); 

    final Calendar calendar1 = getThing("ONE"); 
    final Calendar calendar2 = getThing("TWO"); 
    final Calendar calendar3 = getThing("THREE"); 
} 

public static <T> T getThing(String key) { 
    return (T) myMap.get(key); 
} 

Così si stanno mettendo a class di extends Object nella vostra Map (in modo che qualsiasi class).

Tuttavia, quando si chiama getThing si esegue una trasmissione implicita sul tipo desiderato. Dovrebbe essere abbastanza ovvio che posso chiamare lo getThing con qualsiasi class e tenterò ciecamente di lanciarci su di esso.

Nell'esempio precedente sto inserendo alcune cose nel mio Map e quindi nel tentativo di recuperarle tutte come Calendar s.

Answer 3

Un modo classico per gestire questa situazione è un "contenitore eterogeneo typesafe":

Map<Class<?>, IFace> faces; 

public <T extends IFace> T getFace(Class<T> key) { 
    return t.cast(faces.get(key)); 
} 

si utilizza la classe dell'interfaccia come una chiave, piuttosto che una stringa, e quindi è possibile utilizzare la classe passata come chiave per trasmettere in modo sicuro il valore restituito al tipo corretto.