Generics : defining their relationship in order to ovloard a method

[James JVogt]

I want to do something like:

class DoubleMap {
   public Integer put(Integer key, Integer value);
   public String put(Integer key, String value);
}

but with generics:

class DoubleMap<K_T, V1_T, V2_T> {
   public V1_T put(K_T key, V1_T value);
   public V2_T put(K_T key, V2_T value);
}

of course the compiler complains that both puts have the same erasure and thus signature. Is something like this possible in Java? I would rather not make two methods "putT1(...)" "putT2(...)" since that would confuse things. Overloading by return type would also be great (for get() methods)... but I am pretty sure that is impossible in Java.
(I need this "double map" to ensure that the maps vary together in a specific way when one or the other is changed).

[Henry Wong]

Well, you could try it as a generic method...

class DoubleMap<K_T> {   
   public <V_T> V_T put(K_T key, V_T value);   
}  

This way, you can support both types without using overloading... unfortunately, the issue here is that you can't limit it to only two types.

Henry

[James JVogt]

That actually won't work either since you can't determine what type you got (at runtime) and then put that type the appropriate map. I.e., I can't do

if (value instanceof SOME_GENERIC_TYPE_PARAMETER_SUPPLIED_BY_USER_OF_CLASS) {
}

but I found that my request is impossible in Java due to generics being implemented via erasure.

Well I suppose I could have the user pass in two class objects to the constructor... and compare the classes of the passed in objects against those class objects.

[Henry Wong]

That actually won't work either since you can't determine what type you got (at runtime) and then put that type the appropriate map. I.e., I can't do

Hmmm.... you're absolutely correct. Without the instanceof operator, it isn't possible to determine the type. I figured out a way of avoiding the need for the operator -- by using maps of maps.... but even in that case, I couldn't avoid a typecast.

And regardless, this doesn't solve your problem of restricting it to only two types.

Anyway, in case you are interested.... here is my (somewhat broken) solution...

private Map<Class<?>, HashMap<K, ?>> mapOfMaps = new HashMap<Class<?>, HashMap<K, ?>>();

public <V> V put(K key, V value) {
    Class<?> mapKey = value.getClass();
    HashMap<K, V> map = (HashMap<K,V>) mapOfMaps.get(mapKey);

    if (map == null) {
        map = new HashMap<K, V>();
        mapOfMaps.put(mapKey, map);
    }
    return map.put(key, value);
}   

Henry

[Rob Spoor]

Henry Wong wrote:

private Map<Class<?>, HashMap<K, ?>> mapOfMaps = new HashMap<Class<?>, HashMap<K, ?>>();

That should be

Map<Class<?>, Map<K, ?>> mapOfMaps = new HashMap<Class<?>, Map<K, ?>>();

This still allows you to put HashMap instances, but should you want to change you can turn it into a TreeSet or LinkedHashMap by only changing line 9 of your original code.