Question

How can I create a generic class, which takes the class type from the generic type argument that is placed when creating/injecting this generic class?
My goal is to specify eg MyGeneric<User>, and the generic class should then be capable to use the User class in all method calls. Without having to explicitly supplying User.class in the constructor of the generic additionally.

Something like:

class MyGeneric<T> {
    public MyGeneric() {
        someService.create(Class<T>, someString);
    }
}

class Usage {
    @Inject
    MyGeneric<User> myuser;
}

How is this done propertly?

Answer 1

What you can do is write the instantiation code in a superclass and then extend it for each particular generic type (little or no code is required in subclasses, but the subclasses are mandatory as they’re the only way to avoid type erasure):

abstract class MyGeneric<T> {

    private T instance;

    public MyGeneric(String str) {
        // grab the actual class represented by 'T'
        // this only works for subclasses of MyGeneric<T>, not for MyGeneric itself !
        Class<T> genericType = (Class<T>) ((ParameterizedType)getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
        try {
            // instantiate that class with the provided parameter
            instance = genericType.getConstructor(String.class).newInstance(str);
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
    }
}

class MyUser extends MyGeneric<User> {
    public MyUser() {
        // provide the string to use for instantiating users...
        super("userStr");
    }
}

class User { /*...*/ }

Edit: made the generic class abstract to enforce the usage of subclasses.

It can also be used with anonymous classes like:

new MyGeneric<User>("..string...") {}

I think this is the closest to your initial goal you can get…