Is there any hack to know the actual concrete class of the generic of an instance at runtime?

Question

I'd like to find a hack to infer the actual generic instance of another instance's var in runtime, without:

• Changing my needed method signature (adding the helper parameter Class<T>, the obvious way)

• Having to instanceof all possible subtypes in a hardcoded way

  MyInterface<? extends Number> myInterface = whateverReturnsWildcardDoubleInterface();
  Class<?> type = inferInstanceType(myInterface);
  assert type == Double.class;  
  
  /** This is the method that represents the code I am looking for  with the conrete signature**/
  public <T extends Number> Class<T> inferInstanceType(MyInterface<T> myInterface){
      return T.class; //Concrete T (can or cannot be the very Number)  
  }
  

Ideally, it should return Double when T is particular subtype Integer,Double.. and Number when T is Number

I checked reflection, several "TypeResolver"/"GenericResolver" libs (as the one in Spring or others in Github), but I cannot fin a way to hack it.

EDIT: I reached the conclusion that he only feasible way to do that would be some kind of very complex reflection through the stack trace up to the acutal line that passes the type in the very instantiation

EDIT2: I know it's stupid... but I solved it by simply adding a T getT() method to my interface, so I could return myInterface.getT().getClass()

Answer 1

Disclaimer: This solution is provided as a hack tailored to my understanding of your setup, i.e. one generic interface with a single type parameter, multiple classes, which are not themselves generic, directly implementing this one interface alone, and implementing no other generic interfaces, directly or indirectly.

Assuming that all of the above is true, there is a relatively straightforward way of hacking a solution: calling getClass().getGenericInterfaces() returns a Type object that provides the actual type with which your generic interface has been instantiated.

interface MyInterface<T extends Number> {
    T getVal();
}
class DoubleImpl implements MyInterface<Double> {
    public Double getVal() {return 42.42; }
}
...
public static void main (String[] args) throws java.lang.Exception {
    MyInterface<? extends Number> x = new DoubleImpl();
    Type[] ifs = x.getClass().getGenericInterfaces();

    System.out.println(ifs.length);
    for (Type c : ifs) {
        System.out.println(c);
        Type[] tps = ((ParameterizedType)c).getActualTypeArguments();
        for (Object tp : tps) {
            System.out.println("===="+tp); // <<== This produces class java.lang.Double
        }
    }
}

Demo.

Answer 2

As assylias pointed out, Java's erasure will make that information unavailable at runtime - and thus a need for a hack.

On the assumption that myInterface has a getter for T, as in, MyInterface.getValue():T (or the hack would be to add it) you could do something like this (ignoring the possibility that getValue() could return null):

public <T extends Number> Class<T> inferInstanceType(MyInterface<T> myInterface){
    return myInterface.getValue().getClass()
}

Below is the full implementation

public class Q34271256 {

  public static interface MyInterface<T> {
    T getValue();
  }

  public static class MyDoubleClass implements MyInterface<Double> {
    private final Double value;
    public MyDoubleClass(Double value) {
      this.value = value;
    }
    @Override
    public Double getValue() {
      return value;
    }
  }

  public static class MyIntegerClass implements MyInterface<Integer> {
    private final Integer value;
    public MyIntegerClass(Integer value) {
      this.value = value;
    }
    @Override
    public Integer getValue() {
      return value;
    }
  }

  @SuppressWarnings("unchecked")
  public static <T extends Number> Class<T> inferInstanceType(MyInterface<T> myInterface){
    Number value = myInterface.getValue();
    if (value == null) return null;
    return (Class<T>)value.getClass();
  }

  public static void main(String...args) {
    List<MyInterface<? extends Number>> list = Arrays.asList(
        new MyDoubleClass(1.1),
        new MyIntegerClass(5)
    );
    for (MyInterface<? extends Number> myInterface : list) {
      Class<?> type = inferInstanceType(myInterface);
      System.out.printf("%s inferred type is %s\n",
          myInterface.getClass().getName(),
          type.getName());
    }
  }
}

And the output should look something like this:

MyDoubleClass inferred type is java.lang.Double
MyIntegerClass inferred type is java.lang.Integer