Help inheriting multiple generic interfaces of same type

Question

Hi-
I am trying to re-factor some current code bloat.
Here is the solution I want
I want to define one generic subscriber interface, e.g.
public interface Subscriber <TYPE> {
public void valueChanges (TYPE T) ;
And then I would like to (in theory) implements a class like this
public class MyClass extends foo implements Subscriber<String> ,
Subscriber <Integer> , Subscriber <Double> {
public void valueChanged (String s) {
public void valueChanged (Integer s) {
public void valueChanged (Double s) {
But this does not seem to be allowed becuase it says you can not inherit the
same interface multiple times. I even tried something like this
public interface Stringsubscriber implements Subscriber <String> for all the
interfaces to specialize. That does not work.
Can this be done (via some mechanism) in java or is this not possible.
I am just learning the way generics work (I come from c++ world were templates
are a bit more flexible and work a bit differently so its trying).
Any hlep would be great.
thanks in advance
matt

Answer 1

OK, Bruce, I'll bite: how do you attach
parameterized types as annotation member values?
There's no ".class" for them. It must be textual,
, right? No.
Actually I don't attach them as such, I put them somewhere else where I can find them by association.
And you parse these stringual declarations
later?The mirror API does not have an equivalent method to com.sun..javadoc.ClassDoc.findClass(String name), so you can't do it textually unless you require every type to be fully qualified. Thats too ugly for me.
I tried writing a recursive annotation like this@interface Type {
    Class<?> value();
    Type[] args() default {};
}but you can't write cyclic annotations (whose members are of its own type, directly or indirectly).
So I thought that since I was annotating a class, I would just create some placeholder interfacesinterface S2WFGC1<T1> {}
interface S2WFGC2<T1,T2> {}
thru
interface S2WFGC15<T1,T2,... T15> {}and do this
    @MyAnnotation(base=Map.class, add=@Flavor(EventDispatcher.class))
class MyClass implements S2WFGC2<
                Map<String,Integer>,
                EventDispatcher<FooListener,FooEvent>
            > {
}which gets interpreted as
    @MyAnnotation(
        base=Map<String,Integer>,
        add=@Flavor(EventDispatcher<FooListener,FooEvent>)
class MyClass {}So I just put the raw type in the annotation, and for each of those (because the annotation is more complex than above), I get the type parameters from the S2WFGCn interface. I just use whichever S2WFGCn interface has the right number of type parameters.
For each type in the annotation, if it is generic, I just read the next type argument from the S2WFGCn superinterface and use that instead (but error if its raw type is not the same as the annotation value). Each S2WFGCn actually extends S2WFGC, which makes it easy to find the S2WFGCn amongst (possibly other) superinterfaces.
The S2WFGCn interfaces are sort of marker interfaces, but as well as having no methods, they also have no meaning. They are more like a variable for holding an array of types at the meta level.
Sorry, but thats the best I can come up with. Its not pretty for sure, and I'd rather have a nicer mechanism, but for this application at least, the benefits are still positive, since in most cases there are no generic classes, so all the trickery disappears, and when there are generics, the ends justify the means.
If only the JSR-175 EG had realised that generics was a meta type of the language...
This was their biggest failure by a country mile.