Using a Class instance as a type parameter

Question

I'm trying to use reflection to get a list of classes implementing an abstract class, Detector. I would like to use the elements of this list (of type Class<T extends Detector>) as a type parameter for another class, DetectorWrapper<T extends Detector>, so that I can easily instantiate T within that class (i.e., using new T(...)). Is it possible to use reflection for this, or should I instead pass Class<T> to DetectorWrapper and use reflection to invoke the constructor whenever I need an instance of T?

Answer 1

There is no way to use a Class object as a type parameter, but that doesn’t matter, as a type parameter is exactly what you can never instantiate anyway, i.e. you can’t say new T().

So you need a Class object to instantiate an object of that type and may define a relationship to the type parameter:

class DetectorWrapper<T extends Detector> {
    final List<T> detectors;

    DetectorWrapper(Class<? extends T>... types) {
        ArrayList<T> result=new ArrayList<>(types.length);
        try {
            for(Class<? extends T> type: types) result.add(type.newInstance());
        }catch(InstantiationException|IllegalAccessException ex) {
            throw new IllegalArgumentException(ex);
        }
        this.detectors=result;
    }
}

Though for most practical issues, the type parameter of the DetectorWrapper class is obsolete, i.e. you may use

  class DetectorWrapper {
      final List<Detector> detectors;

      DetectorWrapper(Class<? extends Detector>... types) {
          ArrayList<Detector> result=new ArrayList<>(types.length);
          try {
              for(Class<? extends Detector> type: types) result.add(type.newInstance());
          }catch(InstantiationException|IllegalAccessException ex) {
              throw new IllegalArgumentException(ex);
          }
          this.detectors=result;
      }
  }

Having classes like

class Detector {}
class Foo extends Detector {}
class Bar extends Detector {}

you can instantiate a DetectorWrapper via new DetectorWrapper(Foo.class, Bar.class).

Note that Class.newInstance() assumes a no-arg constructor. You may use type.getConstructor(parameterTypes).newInstance(initargs); instead, in case you know a common constructor signature.

With Java 8, there is a more robust, non-reflective alternative:

class DetectorWrapper {
    final List<Detector> detectors;

    DetectorWrapper(Supplier<? extends Detector>... types) {
        ArrayList<Detector> result=new ArrayList<>(types.length);
        for(Supplier<? extends Detector> s: types) result.add(s.get());
        this.detectors=result;
    }
}

which can be instantiated like new DetectorWrapper(Foo::new, Bar::new), assuming the same setup as above.

An equivalent alternative implementation would be:

class DetectorWrapper {
    final List<Detector> detectors;

    DetectorWrapper(Supplier<? extends Detector>... types) {
        detectors=Arrays.stream(types).map(Supplier::get).collect(Collectors.toList());
    }
}

But if you discover the Class objects dynamically at runtime, there is no way around the reflective instantiation.