Bdtjtk

Suppose you have the following abstract java class:

public abstract class AbstractRequestHandler<I,O> {

    I input;

    O output;

}

and the following child classes hierarchy:

public abstract class AbstractUserRequestHandler<I extends User,O> extends AbstractRequestHandler<I,O>{...}

public abstract class AbstractUniversityRequestHandler<I extends UniversityUser> extends AbstractUserRequestHandler<I,String>{...}

public class StudentRequestHandler extends AbstractUniversityRequestHandler<Student>{...}

public class TeacherRequestHandler extends AbstractUniversityRequestHandler<Teacher>{...}

Suppose you need to use at a given point on the super class the generic type, for example in order to deserialize on the constructor the request json to the specific request object using gson library as follow:

public AbstractRequestHandler(final String inputJson) {

        input = new Gson().fromJson(inputJson,typeOfI);

}

You need the type of generic I within variable "typeOfI"

Is there a global solution that allows to get the generic type specified by a concrete child class that respects the following constraints?

1. The type is gotten at runtime regardless the child classes hierarchy ( that can be also more complex the one given as example on this question )


2. The developer just needs to define the generic extending the super class without manually specify the generic type somewhere on concrete child class ( for example on overrided method or constructor )
   

So that if you want to define a new concrete child that assign a new value to a generic you can just write the following concrete class for example:

public class StudentRequestHandler extends AbstractUniversityRequestHandler<Student>{



    public StudentRequestHandler(String inputJson) {

        super(inputJson);

    }



}

I found the following solutions but they don't respect both the asked solution constraints.

Solution that break constraint n°2

A solution could be to define an abstract method on the superclass as follow

protected abstract Type getRequestType();

and then implement it on every concrete child class that defines the generic:

public class StudentRequestHandler extends AbstractUniversityRequestHandler<Student>{



    public StudentRequestHandler(String inputJson) {

        super(inputJson);

    }



    @Override

    protected Type getRequestType() {

        return Student.class;

    }

}

Then the getRequestType() method can be used on constructor on the target superclass:

public AbstractRequestHandler(final String inputJson) {

        request = new Gson().fromJson(inputJson,getRequestType());

}

But even if it works regardless the child classes hierarchy ( respect constraint n°1 ) the developer should manually implement an abstract method on each concrete child class.

Solution that break constraint n°1

If the hierarchy is simple having only a direct child that extend from the target superclass, as for example:

public class TeacherRequestHandler extends AbstractRequestHandler<Teacher,String>{...}

a working solution has been proposed by @naikus ( https://stackoverflow.com/users/306602/naikus ) on the following stackoverflow thread:
Using a generic type of a subclass within it's abstract superclass?

However this doesn't work if the concrete class is not a direct child of the superclass that defines the generics ( as the one proposed as example on this question ).

You can't get generic parameter without inheritence because of generics in java has type erasure : https://docs.oracle.com/javase/tutorial/java/generics/erasure.html

You need to do approach which you've been shared in your question. Using inheritence and ParameterizedType :

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