Generics version of "new T()"?

[David O'Meara]

Just a hypothetical question, but assuming that a generic type T has a concrete implementation and a no-arg constructor, is there a clean way to get a new instance?

[Raymond Tong]

David O'Meara wrote:Just a hypothetical question, but assuming that a generic type T has a concrete implementation and a no-arg constructor, is there a clean way to get a new instance?

http://forums.sun.com/thread.jspa?threadID=769984
The URL above seems to has some discussion on that though it was quite old.

class Dummy<T> {
	private Class<T> clazzOfT;
	public T getInstance() throws Exception {
		//return new T(); // won't compile
		//return T.newInstance(); // won't compile
		//return T.class.newInstance(); // won't compile
		return clazzOfT.newInstance();
	}
}

[Rob Spoor]

Raymond is right. The only way to instantiate any T instance is through a Class<T>. Either use newInstance() for getConstructor(...).newInstance(...).
Similarly, the only way to instantiate any T[] is to use java.lang.reflect.Array with a Class<T>. You'll still need to do a cast, suppressing the warning, but that's safe:

public T[] createArray(Class<T> cls, int size) throws Exception
{
    @SuppressWarnings("unchecked") T[] array = (T[])Array.newInstance(cls, size);
    return array;
}

[David O'Meara]

The reason it is more theoretical is that it is currently a utility method used to map from a DB entity to a POJO (yes I know they can be detached, long story) for a variety of enumerated types. More or less.

	public static <T extends Value> T map(T target, Item source) {
		target.setId(source.getId());
		target.setName(source.getName());
		return target;
	}

I currently use it like this, which is not terribly difficult

    
    result.setMyValue(MyUtil.map(new MyValue(), source.getMyItem());

where there are several similar types for MyValue and MyItem

[Rob Spoor]

	public static <T extends Value> T map(Class<T> targetClass, Item source) throws Exception {
		T target = targetClass.newInstance();
		target.setId(source.getId());
		target.setName(source.getName());
		return target;
	}

        result.setMyValue(MyUtil.map(MyValue.class, source.getMyItem());

Is that something you'd prefer?

I guess you want something more like

result.setMyValue(MyUtil.map(source.getMyItem());

where it uses type inference to determine T and instantiate it, but that's simply not possible.


Perhaps generics can be extended in the future, something like this:

public static <T() extends Value> T map(Item source) // () indicates a non-args constructor must exist
{
    T target = new T(); // because the generic type has () it will have a non-args constructor
    target.setId(source.getId());
    target.setName(source.getName());
    return target;
}

public static <T(int) extends Value> T map(Item source, int value) // (int) indicates a constructor that takes an int must exist
{
    T target = new T(value); // because the generic type has (int) it will have a constructor that takes an int
    target.setId(source.getId());
    target.setName(source.getName());
    return target;
}

Omitting the constructor argument types will then use the current situation, where instantiation is impossible.

However, because of type erasure I doubt this will ever happen. T is no longer known at run time. For this to work the methods would need to be inlined, as that's the only way to link T and its actual value. Or type erasure needs to be removed, but that would cause a lot of compatibility issues.

[David O'Meara]

If you have something like this

    
class MyClass<T> implements MyInterface<T>

then you can extract the type T from the supertype provided the supertype contains the generic binding using the following:

final Class<T> myType;
public MyClass()
{
    this.myType = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass())
				.getActualTypeArguments()[0];
}

and would then be able to use myType.newInstance(), but not really applicable to my situation.

[David O'Meara]

But I haven't found a way to do the same when the class is declared without a binding on the supertype