How to Get a Class Instance of Generic Type T

How do I get a class instance of generic type T?

The short answer is, that there is no way to find out the runtime type of generic type parameters in Java. I suggest reading the chapter about type erasure in the Java Tutorial for more details.

A popular solution to this is to pass the Class of the type parameter into the constructor of the generic type, e.g.

class Foo<T> {
    final Class<T> typeParameterClass;

    public Foo(Class<T> typeParameterClass) {
        this.typeParameterClass = typeParameterClass;
    }

    public void bar() {
        // you can access the typeParameterClass here and do whatever you like
    }
}

What's the equivalent of T.class in a generic class?

This is a limitation of generics in Java. The generics only exist at compile time, i.e. at runtime the object is just a BaseConverter, and so you can't query it about its generic type. The easiest solution is usually to pass in a Class<TModel> object (as you are doing) when you call the method. You can also pass it to the constructor for BaseConverter if you don't want to have to pass it in multiple times.

Instantiate a generic class T object and return it

Generic types are a compile-time notation for ensuring type safety. They are erased at runtime.

This means T and U do not exist at runtime. Which is why you can’t instantiate them.

You can, however, pass in the constructors yourself:

public class Button<T, U> {
    private final Supplier<? extends T> tConstructor;
    private final Supplier<? extends U> uConstructor;

    public Button(Supplier<? extends T> tConstructor,
                  Supplier<? extends U> uConstructor) {

        this.tConstructor = tConstructor;
        this.uConstructor = uConstructor;
    }

    public T observe() {
        return tConstructor.get();
    }

    public U click() {
        return uConstructor.get();
    }
}

And you can pass those constructors as method references:

public class FirstPage {
    public Button<FirstPage, SecondPage> buttonOnFirstPage =
        new Button<>(FirstPage::new, SecondPage::new);
}

How to create an instance just by generic type T

The generic information will be erased at compile time, so there will be no T anymore during runtime (you loose the information). Thats why you somewhere will need a Class<> to store the information.

The most clean & simple solution form my point of view is to pass in the class to to the constructor. I know you requested it to be without any constructor argument, but I do not think this is possible.

Code Sample

public abstract class AbstractBase<T> {

    private final T genericTypeObject;

    protected Base(Class<T> type){
        try {
            genericTypeObject = type.newInstance();
        } catch (InstantiationException e) {
            // Handle
        } catch (IllegalAccessException e) {
            // Handle
        }
    }
}

public class Child extends Base<SomeClass> {

    public Child () {
        super(SomeClass.class);
    }
}

Alternative Solution

Using a Supplier (thanks for the comment @Jorn Vernee):

public abstract class AbstractBase<T> {

  private final T genericTypeObject;

  public AbstractBase(Supplier<T> supplier) {
    genericTypeObject = supplier.get();
  }
}

public class Child extends AbstractBase<SomeClass> {

  public Child() {
    super(SomeClass::new);
  }
}

Create instance of generic class parameter

In short: No it's not possible without a reference to a constructible runtime value.

The reason is that TypeScript types only exist at compile time (not at runtime) and can't be used as values. In your example, T is only a type (not a runtime value). This is the JavaScript that your TypeScript program compilation would produce:

class Bar {}

class Foo {
  constructor() { }
  create() {
    return new T();
  }
}

const bar = new Foo().create();
//                    ^^^^^^^^
// Exception is thrown: ReferenceError: T is not defined

public class Foo<T> 
{
    private Class<T> type;

    public Foo(Class<T> type) { this.type = type; } 
}

Foo<Integer> test = new Foo<Integer>(Integer.class);

Class<T> persistentClass = (Class<T>)
   ((ParameterizedType)getClass().getGenericSuperclass())
      .getActualTypeArguments()[0];

System.out.println(
    // I've assumed the Consumer interface is the first one, to keep it brief
    ((ParameterizedType)onCatch.getClass().getGenericInterfaces()[0])
        .getActualTypeArguments()[0]
 );

onCatch(new Consumer<RuntimeException>() {
    @Override
    public void accept(RuntimeException e) {

    }
});

onCatch((RuntimeException e) -> {});

private static void lambda$caller$0(RuntimeException e) {

}

onCatch(RuntimeException.class, e -> {});