Re: Generics question
Mark Space wrote:
kelvSYC wrote:
Suppose I have a class Foo, which has subclasses Foo1 and Foo2. Now,
suppose I need a map whose key type is Class<T extends Foo> and whose
value type is Set<T> (that is, if the key type is Foo1.class, then the
value type is Set<Foo1>).
Is it even possible to declare such a type using generics or do I have
to do something in a roundabout way?
What is the context for this type? A return type? A parameter type? A
local variable? (I'll limit myself to these most likely cases, but
there may be more subtle ones.)
I think that Mark Space has had to make an assumption about this in
order to give an example:
I think so, give a certain assumptions about what you really want.
Try this method:
public static <X extends Foo> Map<Class<X>,Set<X>> getFooMap() {
return new HashMap<Class<X>,Set<X>>();
}
It's somewhat roundabout, although not too much I think.
Indeed, I don't think it's roundabout at all - it's exactly what you
need (although I think this particular example doesn't buy you much; see
below [1]).
When you use <?> in method declarations, for example:
void func(List<?> a, Map<?,?> b) ...
....you're really saying:
<X, Y, Z> void func(List<X> a, Map<Y,Z> b) ...
....and then not using X, Y and Z anywhere else. The OP describes a case
where two unknown types must be the same, so <?> can't be used. The
unknown type must be named and constrained (with <X extends Foo> on the
method above), and then identified in both positions.
In other contexts, such as those below (declaring local variables), you
almost always know what specific type you're dealing with (even if it's
yet another type parameter declared in an enclosing context). Foo, Foo1
and Foo2 are known in the first three cases below, so there's no need
for any <X>:
Then you can do the following. The last line below is a compile time
error.
Map<Class<Foo>,Set<Foo>> foos = getFooMap();
Map<Class<Foo1>,Set<Foo1>> foos1 = getFooMap();
Map<Class<Foo2>,Set<Foo2>> foos2 = getFooMap();
Map<Class<Foo1>,Set<Foo2>> foosX = getFooMap(); // oops
[1] I said this doesn't buy you much. Here's what I mean.
You could use a much more general method for creating maps in these cases:
static <K,V> HashMap<K,V> newHashMap() { return new HashMap<K,V>(); }
Map<Class<Foo>,Set<Foo>> foos = newHashMap();
Map<Class<Foo1>,Set<Foo1>> foos1 = newHashMap();
Map<Class<Foo2>,Set<Foo2>> foos2 = newHashMap();
Map<Class<Foo1>,Set<Foo2>> foosX = newHashMap(); // not oops
However, note that the last line won't be an error. But who cares? If
it really matters to the subsequent code, the compiler should pick it up
later. For example:
for (Foo1 f : foosX.get(Foo1.class)) { ... } // error
If it matters to some external code, that code's API should impose the
necessary constraints, and again the compiler will pick it up:
ExternalStuff.doSomething(foos1); // error, because...
class ExternalStuff {
public static <T extends Foo> void doSomething(Map<Class<T>, Set<T>> data) {
...
}
}
Here's the lot:
<sscce>
import java.util.*;
public class FooStuff {
class Foo { }
class Foo1 extends Foo { }
class Foo2 extends Foo { }
public static <K,V> HashMap<K,V> newHashMap() {
return new HashMap<K,V>();
}
public static void func() {
Map<Class<Foo>,Set<Foo>> foos = newHashMap();
Map<Class<Foo1>,Set<Foo1>> foos1 = newHashMap();
Map<Class<Foo2>,Set<Foo2>> foos2 = newHashMap();
Map<Class<Foo1>,Set<Foo2>> foosX = newHashMap();
// Does it matter to our code?
for (Foo2 f : foosX.get(Foo1.class)) { }
//for (Foo1 f : foosX.get(Foo1.class)) { } // error
// Does it matter to something external?
doSomething(foos);
doSomething(foos1);
doSomething(foos2);
//doSomething(foosX); // error
}
public static
<T extends Foo> void doSomething(Map<Class<T>, Set<T>> data) { }
}
</sscce>
Cheers!
--
ss at comp dot lancs dot ac dot uk