Generics vs. Reflection in Java

[Jagruti23]

I have to crack a tough nut. Given the following interfaces:

interface Entity (... )
BaseInterface <e MyEntity> interface extends ... ( )
interface interface Special extends <e MyEntity> extends BaseInterface <E> {...}

Special interface and a suitable implementation this:

MyClazz <e MyEntity> class extends implements interface <E> (Special ... )

Now let I want to create the instances of MyClazz not yourself, but do these over a factory method:

public static <B extends BaseInterface <E>, E extends Entity> B getInstance (Class clazz <B>) (... )

The call currently looks like this:

Class cls = <SpecialInterface> SpecialInterface.class; 
Special Interface <E> si = getInstance (cls); 
si.doSth ();

[DllD]

I think you should look initially make clear how the Java Generics work, the types of information is only available at compile time and not to maturity. Each generic type for example.

class Foo extends <A Bar> 
( 
A GetIt (){...} 
)

has indeed at compile-time generic capabilities explained. However, there is no corresponding code in the bytecode depict these properties could.

[Jagruti23]

I would like to thank you for trying to help me sooner The code that I mentioned works only once, but leads firstly to a compiler warning (due to 'unchecked conversation'). And secondly, I can in MyClazz (via reflection) is no longer figure out what specific type of (<E>) my body is now. So actually I need the following:

Class <Special Interface <E>> cls = ?????

So here:

Class <Special Interface <E>> cls = (Class <Special Interface <E>>) SpecialInterface.class;

bleats the compiler ('Can not cast from class to class <SpecialInterface> <Special Interface <E>>'). Any ideas would be appreciable.

[Shell]

The compiler is now trying a workaround (Type Erasure) to come around this restriction. It replaces each generic type against the type of object and adds the appropriate casts. The following is an example that explains the same :

To compile:
Foo = new Foo <BarImpl> aFoo <BarImpl> ();
Bar = abar aFoo.getit ()

At runtime:
AFoo foo = new Foo ();
Abar bar = (Bar) aFoo.getit ()

That is what is in the figurative sense. Via reflection so you can not get the information. The compiler warning that you get with your type conversion:

Class cls = <SpecialInterface> SpecialInterface.class;
Special Interface <E> si = getInstance (cls);

has a similar basis. The Special Interface Type information is not included in <E> SpecialInterface.class. (Has something to do with the implementation of Generics) means you walk without a special interface type information into an instance of type information. This generates the compiler warning.

[Jagruti23]

Thank you for your answer!!! However, I believe I have not formulated my problem clearly enough My problem is that I need a Class-typed object of the special interface ... Suppose I have a XXX-Entity:

XXX class implements Entity (... )

Then I could build as just another interface:

Special XXXSpecialInterface interface extends interface XXX (... )

and then later in your code

Class cls = <XXXSpecialInterface> XXXSpecialInterface.class; 
XXXSpecialInterface si = getInstance (cls); 
si.doSth ();

The nice thing is that I might as desired via reflection to find out 'si', that is typed with XXX (note link at the bottom). But I will find no extra interface for each and group of possible types, I want 'simple' only:

Class <Special interface XXX> cls = XXX Special interface. Class; 
Special Interface <XXX> si = getInstance (cls); 
si.doSth ();

[DllD]

It is true that information on Generics can be found in the bytecode, but if I have not left my memory, only for the generic definitions. But not the specific types of instances of generic classes. Moreover, it is already doubtful that the generic type information is effectively accessible, in the above scenario by you. Either you know the production already, come what specific classes are used (then you have the info already on the programming time and create these can without generic Factory), or you know it there yet, then you have in and by the Generics another program run anything.

[Solitario]

Maybe it helps yes, if you describe your solution instead of the idea of the problem, so that what you want to accomplish. use among other things, how do you use the generated instances / what information you want and to programming level need. For example, you write about an "E" as a parameter, but also so must be somewhere concretely proven or provable. May help a factory registry approach depend on the problem?

[Jagruti23]

I mean that you want to help me with my architecture, but I would really reluctant to discuss their meaning and nonsense. It stands for me that am not in doubt. It should be clear that I have here a minimal sample which actually has little relation to reality. Perhaps only this: I have built an OR-Mapper is configured using annotations and generics. The OR mapper must at some point know for which specific entity types because he works at all (and it works reliably well) ... You need not to be the question and yes, I know, and Hibernate JPA and Toplink and JDO and whatever you want the proposal from me now. That is not all my problem - everything works perfectly some time ago, I would like to make only a tiny optimization, and for that I need 'simple' only:

Class <Special interface XXX> cls =???

[Deabelos]

There are no parameterized class objects. Told you that the compiler already. So I said yes and that possibly is a Factory-registry approach in question, where you fetch your first parameter a factory for your class from a registry through which you will create with the specific entity type your instance. For example, like (via inference):

 Special Interface Factory sf = getFactory (SpecialInterface.class); 
Special Interface <YourEntity> sf.create si = (); 
<e Extends Entity> Special <E> interface create ();

[Warner]

It is true that information on Generics can be found in the bytecode, but if I have not left my memory, only for the generic definitions. But not the specific types of instances of generic classes.

That is not correct, the generic definition is deleted by the compiler and also to suppress any information about specific types. Java uses a code-sharing for generics, not like C + + code-Specialization. There is only one class file, it is used for all instantiations of the class whether or Foo <String> <bar>.

 template <class T> 
class Foo 
( 
)

The compiler generates for every generic instance. In the fall of Foo Foo <ns:Bar> <std::string> or a class for string and bar is created. In Java, it looks different, there is only one -> Foo <Object>. In C # this has been implemented differently, C # uses a per-instance type VTable can provide the Information and runtime. But that is regulated within the VM.