Get a Generic Type Class in Java: Why T.class Does Not Work

Java generic type parameters are mostly erased at runtime, so T.class is not available. The usual and safest solution is to provide a Class<T> when constructing the generic object, then store and use that class token where needed.

Java implements generics with type erasure. The compiler uses generic information to check your code, but most type-parameter information is removed from ordinary objects at runtime.

For example, these two declarations have different compile-time types:

Foo<String> strings = new Foo<>();
Foo<Integer> numbers = new Foo<>();

At runtime, however, both are generally just instances of Foo. The runtime does not retain a general-purpose value that says the first object is Foo<String> and the second is Foo<Integer>.

That is why this is invalid:

class Foo<T> {
    Class<T> type = T.class; // Compilation error
}

String.class works because String is a real, concrete runtime class. T is only a type parameter selected by the caller at compile time.

When your code genuinely needs runtime type information—for validation, reflection, object creation, or serialization—make it an explicit dependency by passing a Class<T> object into Foo.

Think of T as a blank label used while the compiler checks a form.

Foo<String>

means “this Foo works with strings” while compiling. Once the program runs, Java usually removes that label from the object. The object cannot look at itself and reliably discover what was written in the blank.

A Class<T> value is like keeping a copy of the label in the object:

new Foo<>(String.class)

Now Foo has an actual runtime object representing the type, so it can inspect it or pass it to APIs that require type information.

Pass and store a Class<T> value, often called a class token.

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

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

    Class<T> getType() {
        return type;
    }
}

Create Foo with a concrete class literal:

Foo<String> textFoo = new Foo<>(String.class);
Foo<Integer> numberFoo = new Foo<>(Integer.class);

System.out.println(textFoo.getType().getName());
System.out.println(numberFoo.getType().getName());

Output:

java.lang.String
java.lang.Integer

The type Class<T> is important. It connects the runtime class token to the same generic type parameter used by Foo<T>. As a result, new Foo<String>(Integer.class) is rejected by the compiler.

A factory method can make construction clearer:

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

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

    static <T> Foo<T> of(Class<T> type) {
        return new Foo<>(type);
    }
}

Foo<String> foo = Foo.of(String.class);

Consider this program:

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

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

    boolean accepts(Object value) {
        return type.isInstance(value);
    }
}

Foo<String> foo = new Foo<>(String.class);

System.out.println(foo.accepts("hello"));
System.out.println(foo.accepts(42));

Step by step:

1. String.class creates a Class<String> object representing the runtime String class.
2. The constructor receives that value and stores it in type.
3. foo.accepts("hello") calls String.class.isInstance("hello"), which returns true.
4. foo.accepts(42) calls String.class.isInstance(42), which returns false.
5. The program prints:

true
false

isInstance is useful because the input is an Object, and it performs a runtime type check without an unsafe cast.

A stored Class<T> is useful when an application needs a runtime description of a generic type.

• JSON or database mapping: A repository or serializer may need User.class to map data into a User object.
• Dependency injection: A container can use a class token as a lookup key, such as container.get(Service.class).
• Runtime validation: Validate that an incoming value matches the type expected by a generic component.
• Reflection: Inspect constructors, methods, fields, or annotations on a known class.
• Plugin registries: Register handlers by the event class they handle, such as OrderCreated.class.

Example of a simple type-aware converter:

class Converter<T> {
    private final Class<T> targetType;

    Converter(Class<T> targetType) {
        this.targetType = targetType;
    }

    Class<T> targetType() {
        return targetType;
    }
}

Converter<String> converter = new Converter<>(String.class);

In production code, prefer making runtime type requirements explicit instead of trying to recover erased generic information.

Constructor injection

Use this when every instance needs the type token:

final class Repository<T> {
    private final Class<T> entityType;

    Repository(Class<T> entityType) {
        this.entityType = entityType;
    }
}

Method parameter

Use this when only one operation needs the type:

static <T> T requireType(Object value, Class<T> type) {
    if (!type.isInstance(value)) {
        throw new IllegalArgumentException("Unexpected value type");
    }
    return type.cast(value);
}

type.cast(value) is preferable to (T) value when you already have a Class<T> token because it performs the runtime check through the supplied type.

Guard clauses

Validate required dependencies early:

this.type = java.util.Objects.requireNonNull(type, "type must not be null");

Important limitation: nested generic types

Class<T> can represent String, User, or List, but it cannot fully represent List<String> versus List<Integer>. Both use List.class at runtime. Frameworks that need the complete nested generic type often use java.lang.reflect.Type or a type-token mechanism instead.

Trying to use T.class

This cannot compile:

class Foo<T> {
    Class<T> type = T.class;
}

T is not a concrete runtime class. Pass Class<T> into the constructor instead.

Assuming getClass() returns T

class Foo<T> {
    Class<?> type() {
        return getClass();
    }
}

This returns the class of the container object, such as Foo, not the type argument such as String.

Using the first element to discover a collection type

T first = values.get(0);
Class<?> type = first.getClass();

This fails for empty collections and can be misleading when subclasses are present. If the type is required, provide it explicitly.

Creating T with new T()

class Foo<T> {
    T create() {
        return new T(); // Does not compile
    }
}

A generic type may not have a no-argument constructor. If creation is needed, pass a Supplier<T>:

import java.util.function.Supplier;

class Foo<T> {
    private final Supplier<T> factory;

    Foo(Supplier<T> factory) {
        this.factory = factory;
    }

    T create() {
        return factory.get();
    }
}

Expecting Class<T> to preserve List<String>

Class<java.util.List<String>> type = java.util.List.class; // Does not compile

Only the raw runtime class is available: List.class. Use reflection Type support when nested generic information is required.

getClass() answers “what class is this particular object?” It does not answer “what generic type argument was used to create this container?”

Class<T> answers “which runtime class did the caller explicitly provide?” This is the preferred option when a generic class needs a concrete class at runtime.

// Store a runtime class token
class Foo<T> {
    private final Class<T> type;

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

Foo<String> strings = new Foo<>(String.class);

• T.class is invalid in Java.
• Java erases most generic type arguments at runtime.
• Pass Class<T> when runtime class information is needed.
• Use type.isInstance(value) for safe runtime checks.
• Use type.cast(value) for a checked cast.
• getClass() returns the class of an object, not its generic argument.
• Use Supplier<T> when you need to create T values.
• Class<T> does not preserve nested parameter details such as List<String>.

Why does T.class not compile in Java?

T is a generic type parameter, not a concrete class name. Java erases most generic type information at runtime, so it cannot create a class literal for T.

What is the preferred way to get the class for generic type T?

Pass a Class<T> value, such as String.class, to the constructor or to the method that needs it.

Can I use getClass() to find T?

No. getClass() returns the runtime class of the current object or value, not the generic argument used for a Foo<T> instance.

Is Class<T> type-safe?

Yes, in normal use. For example, new Foo<String>(Integer.class) does not compile because Integer.class is a Class<Integer>, not a Class<String>.

Can Class<T> represent List<String>?

Not fully. List<String> and List<Integer> both have List.class as their raw runtime class. Use Type or a type-token pattern if the element type matters.

How can I instantiate a generic type T?

Usually pass a Supplier<T> such as User::new. This avoids assuming that every possible T has a no-argument constructor.

Can reflection recover the generic type argument?

Sometimes it can inspect generic information declared on a subclass, field, or method signature. It is not reliably available for every ordinary generic object, so explicit Class<T> injection is usually simpler.

• Java type erasure — explains why generic type arguments are usually unavailable at runtime.
• Class literals — covers values such as String.class and User.class.
• Java reflection — uses Class and related APIs to inspect runtime types.
• Generic methods — shows how type parameters work in methods as well as classes.
• Bounded type parameters — restricts T to types with required capabilities.
• Supplier functional interface — provides a clean way to construct values of generic type T.
• Java Type and ParameterizedType — represents nested generic declarations such as List<String>.