Generics: Get name of instance

Question

I have a method which returns a List<Property<?>>.

Property is a type having one generic parameter:

public class Property<T extends Comparable<T>> { ... }

Having a list of mixed-typed properties, I cannot know what type parameter a specific element has.

I would like to do something like that:

List<Property<?>> list = getList();
for(Property<?> crt : list)
{
    PropertyWrapper<?> crtWrapper = new PropertyWrapper(crt.getGenericType());
    //                        I know this doesn't exist ----^
}

In one sentence: I need the PropertyWrapper to have the same generic template argument as the current Property does. Is there any way to do this?

I could apply a suggestion as stated in https://stackoverflow.com/a/3437930/146003 but even if I do this, how to instanciate the appropriate PropertyWrapper<XXX> then, only having an instance of Class<T>?

I can modify Property<?> if required. I also don't mind if reflection needs to be used (I assume it needs to be)

---

EDIT: I forgot something. In fact I cannot instanciate the wrapper by the line

PropertyWrapper<?> crtWrapper = new PropertyWrapper(crt.getGenericType());

because I have specialized subclasses (PropertyWrapper_String).

Now I see two possibilities:

1: Instanciate the class by string:

String strGenericType = "";
Class<?> wrapperClass = Class.forName("PropertyWrapper_" + strGenericType);

2: Is there any way to specialize a generic class without creating a subclass?

---

Many thanks in advance for your tips

Answer 1

Try creating the following method:

<T> PropertyWrapper<T> createWrapper(Property<T> property){
      return new PropertyWrapper<T>(property);
}

Then call it as such.

List<Property<?>> list = getList();
for(Property<?> crt : list)
{
    PropertyWrapper<?> crtWrapper = createWrapper(crt);
}

The reason the above works is that the generic type T is inferred from the argument and is locked down for the entire method. Unlike using <?> in the loop where each instance of <?> is inferred to be a different type.

Edit:

To deal with the issue of having a different class type depending on the class in the wrapper, consider a Map where the key is the class being wrapped and the value is the wrapper.

Map<Class<?>, Class<?>> myMap;

Then you could so something like this:

Class<?> wrappedType = property.getGenericType();
Class<?> wrapperClass = myMap.get(wrappedType);
PropertyWrapper<?> wrapper = (PropertyWrapper<?>) wrapperClass.newInstance();

Although you might need to do something like this if you need to pass an argument.

Constructor<?> constructor = wrapperClass.getDeclaredConstructor(property.getClass());
PropertyWrapper<?> wrapper = (PropertyWrapper<?>) constructor.newInstance(property);