Generics: come applicare restrizioni tra chiavi e valori in una mappa

Question

Il problema: Ho una funzione di interfaccia oggetto definito in una classe:

public static interface FunctionObject<T> { 
     void process(T object); 
    } 

ho bisogno generico perché mi piacerebbe usare T metodi nelle implementazioni del processo.
Poi, in altre classe generica, ho una mappa dove ho classi come chiavi e oggetti funzione come valori:

Map<Class<T>, FunctionObject<T>> map; 

ma voglio anche la mappa di accettare le classi sottotipo e oggetti funzione di supertipi DEL Tipo chiave, così ho fatto questo:

Map<Class<? extends T>, FunctionObject<? super T>> map; //not what I need 

l'idea di base è quella di essere in grado di utilizzare la mappa come segue:

//if T were Number, this should be legal 
    map.put(Class<Integer>, new FunctionObject<Integer>(){...}); 
    map.put(Class<Float>, new FunctionObject<Number>(){...}); 
    map.put(Class<Double>, new FunctionObject<Object>(){...}); 

come voglio rispettare la FunctionObject ha il tipo di chiave classe o un supertipo, quello che mi piacerebbe davvero definire è questo:

Map<Class<E extends T>, FunctionObject<? super E>>> map; 

Come posso ottenere l'effetto desiderato? Un contenitore eterogeneo tipicamente è l'unica opzione? Come apparirebbero i tipi generici di Map per consentirne il popolamento da un riferimento?

Answer 1

contenitore parametrizzata, sembra funzionare bene:

public class MyMap<T> 
{ 
    interface FunctionObject<X> {} 

    private Map<Class<? extends T>, FunctionObject<Object>> map = new HashMap<>(); 

    @SuppressWarnings("unchecked") 
    public <E extends T> void put(Class<E> c, FunctionObject<? super E> f) 
    { 
     map.put(c, (FunctionObject<Object>) f); 
    } 

    public <E extends T> FunctionObject<Object> get(Class<E> c) 
    { 
     return map.get(c); 
    } 

    public static void Main(String[] args) 
    { 
     MyMap<Number> map = new MyMap<>(); 

     map.put(Integer.class, new FunctionObject<Integer>() {}); 
     map.put(Float.class, new FunctionObject<Number>() {}); 
     map.put(Double.class, new FunctionObject<Object>() {}); 
    } 
} 

A cura per conformarsi alla domanda. Purtroppo non c'è modo di evitare il downcasting di opporsi.

Modifica aggiunto get().