Re: Generics and reflection
chauvin.mathieu@gmail.com wrote:
I think that the information that Concrete extends Generic AND that the
generic T is mapped to a Concrete type IS present in bytecode and CAN
be retrieved at run-time, even if it is complicated.
Yes. You right.
In my exemple, we can retrieve the fact that T is actually Concrete by
getting the generic superclass. It actually works, but I'm not sure
that it will be as simple, or even possible, when there are many
generic classes, more than one TypeParameters, ....
For your example class it is possible, and is really simple:
((ParameterizedType) concreteClass.getGenericSuperclass())
.getActualTypeArguments()[0]
But in general, it is not easy (you have to analyze whole inheritance
tree) and sometimes it is simply useless:
class Concrete2 extends Concrete {}
class Concrete3<T> extends Generic<T> {}
class Concrete4<S, T> extends Generic<Concrete3<T>> {}
...
So I strongly suggest to forget about this concept. :)
If you really need to know the type of your class parameters, much
better solution is to directly provide class of this type parameters to
all interested classes, for example:
abstract class Abstract<T extends Abstract<T>> {
final protected Class<T> typeOfT;
protected Abstract(Class<T> typeOfT) {
this.typeOfT = typeOfT;
}
//...
}
with concrete classes like following:
class Concrete extends Abstract<Concrete> {
Concrete() {
super(Concrete.class);
}
}
piotr