CODEWITHSUNDEEP
javagenericsreflection
Mercurious
Mercurious

Reputation: 3268

Instantiating object of type parameter

I have got a template class as follows:

class MyClass<T>
{
    T field;
    public void myMethod()
    {
       field = new T(); // gives compiler error
    }
}

How do I create a new instance of T in my class?

Upvotes: 122

Views: 104849

Answers (7)

user4910279
user4910279

Reputation:

You can get the class object of type T without passing any arguments.

Try this.

static class MyClass<T> {
    Class<?> clazz;

    @SafeVarargs
    public MyClass(T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException("Do not specify arguments");
        clazz = dummy.getClass().componentType();
    }

    @Override
    public String toString() {
        return "MyClass<T = " + clazz.getName() + ">";
    }
}

public static void main(String[] args) {
    MyClass<String> s = new MyClass<>();
    System.out.println(s);
    Object i = new MyClass<Integer>();
    System.out.println(i);
}

output:

MyClass<T = java.lang.String>
MyClass<T = java.lang.Integer>

You can instantiate an object of type parameter T like this.

clazz.getConstructor().newInstance();

Upvotes: 3

Zakir
Zakir

Reputation: 195

One option would be to cast it with Object

{field = (T) new Object();}

field will initially be type Object, but then it will cast down to type T. This is an ugly one because reducing casting to zero is what the goal should be for object initializations. But I think this will work.

Upvotes: 0

Kevendra
Kevendra

Reputation: 109

Class classOfT

        try {
            t = classOfT.newInstance();//new T(); NOTE: type parameter T cannot be instantiated directly
        } catch (Exception e) {
            e.printStackTrace();
        }

Upvotes: -4

erickson
erickson

Reputation: 269877

After type erasure, all that is known about T is that it is some subclass of Object. You need to specify some factory to create instances of T.

One approach could use a Supplier<T>:

class MyClass<T> {

  private final Supplier<? extends T> ctor;

  private T field;

  MyClass(Supplier<? extends T> ctor) {
    this.ctor = Objects.requireNonNull(ctor);
  }

  public void myMethod() {
    field = ctor.get();
  }

}

Usage might look like this:

MyClass<StringBuilder> it = new MyClass<>(StringBuilder::new);

Alternatively, you can provide a Class<T> object, and then use reflection. 

class MyClass<T> {

  private final Constructor<? extends T> ctor;

  private T field;

  MyClass(Class<? extends T> impl) throws NoSuchMethodException {
    this.ctor = impl.getConstructor();
  }

  public void myMethod() throws Exception {
    field = ctor.newInstance();
  }

}

Upvotes: 106

Dan Hodge
Dan Hodge

Reputation: 256

This may be more heavyweight than what you're looking for, but it will also work. Note that if you take this approach, it would make more sense to inject the factory into MyClass when it is constructed instead of passing it into your method each time it is called.

interface MyFactory<T> 
{
    T newObject();
}

class MyClass<T> 
{
    T field;
    public void myMethod(MyFactory<T> factory)
    {
       field = factory.newObject()
    }
}

Upvotes: 16

InverseFalcon
InverseFalcon

Reputation:

Another non-reflective approach is to use a hybrid Builder / Abstract Factory pattern.

In Effective Java, Joshua Bloch goes over the Builder pattern in detail, and advocates a generic Builder interface:

public interface Builder<T> {
  public T build();
}

Concrete builders can implement this interface, and outside classes can use the concrete builder to configure the Builder as required. The builder can be passed to MyClass as a Builder<T>.

Using this pattern, you can get new instances of T, even if T has constructor parameters or requires additional configuration. Of course, you'll need some way to pass the Builder into MyClass. If you can't pass anything into MyClass, then Builder and Abstract Factory are out.

Upvotes: 17

krosenvold
krosenvold

Reputation: 77241

If you're willing to subclass you can avoid erasure as well, check out http://www.artima.com/weblogs/viewpost.jsp?thread=208860

Upvotes: 2

Related Questions