Get type of a generic parameter in Java with reflection

Adapting to real-world scenarios

Applying this knowledge in real-life scenarios necessitates an adaptive approach. Get your hands dirty with these practical applications:

How to fetch generic types of method parameters

When generics pose as method parameters, getGenericParameterTypes() comes to your rescue:

public <T> void myMethod(T param) {
    // The code equivalent of X-ray glasses
    Type[] genericParameterTypes = getClass().getMethod("myMethod", Object.class).getGenericParameterTypes();
    ParameterizedType firstGenericType = (ParameterizedType) genericParameterType[0];
    Type type = firstGenericType.getActualTypeArguments()[0];
    System.out.println("Parameter type: " + type);
}


Mastering super type tokens for interfaces

Exploit super type tokens for interfaces too via getGenericInterfaces:

// Generics and interfaces - a tango of tech
new ParameterizedStuff<String>(){}.revealGenericTypeOfInterface();

abstract class ParameterizedStuff<T> implements List<T> {
    public void revealGenericTypeOfInterface() {
        Type genericInterface = getClass().getGenericInterfaces()[0];
        Type actualType = ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
        System.out.println(actualType);
    }
}


Dodge the pitfalls of type erasure

Prefer concrete parameterizations to dodge the inevitable type erasure:

// Like winning a game of hide & seek!
ArrayList<String> stringList = new ArrayList<String>(){}; // anonymous class with concrete type
Type listType = stringList.getClass().getGenericSuperclass();


Reflecting deeper into type discovery

Piercing through the type erasure dilemma while needing types for runtime operations, think of reflection as your best ally. Let’s slice deeper:

When generic types get nested

For nested generics, like Map<String, List<T>>, apply this recursive approach for every nested generic:

// Recursive method - because monsters are real, and they love spaghetti code
Type resolveNestedGenericType(Type type) {
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;
        for (Type actualTypeArgument : parameterizedType.getActualTypeArguments()) {
            return resolveNestedGenericType(actualTypeArgument);
        }
    }
    return type;
}


Arbitrarily jumping through generic hierarchy

For gracefully handling arbitrary hops in the generics hierarchy, use a robust solution to find types at multiple levels:

// Indiana Jones was never this cool
Type topLevelType = resolveGenericType(SomeClass.class);
Type nestedType = resolveGenericType(topLevelType);


Securing architecture design

Incorporate the insights into architectural principles:

Bypassing the erasure roadblock

Optimize your design for frameworks and libraries that dodge type erasure pitfalls through solid APIs.

Leverage Java 8 goodies

Java 8's default methods in interfaces help in cutting redundancy clutter from your generic interfaces. Interface default methods for the win!

Hooked on reflection functions

Master the reflection toolbox and the right time to call upon getTypeParameters(), getGenericSuperclass(), and getActualTypeArguments().

Surefire Super Type Tokens

Depend on super type tokens, along with anonymous classes, to capture and keep type arguments.

Guarding against JDK compatibility issues

Consider JDK compatibility, and ensure your reflection code is battle-hardened to handle different Java versions. New JDKs might introduce subtle changes impacting reflection APIs.