CODEWITHSUNDEEP
javagenericsinstanceof
Nikordaris
Nikordaris

Reputation: 2327

Test if object is instanceof a parameter type

Is there a way to determine if an object is an instance of a generic type?

public <T> test(Object obj) {
    if (obj instanceof T) {
        ...
    }
}

That clearly doesn't work. Is there an alternative? Like I want to use Java reflection to instantiate a class and then check to make sure it is of type generic T.

Upvotes: 102

Views: 99965

Answers (6)

Ton Snoei
Ton Snoei

Reputation: 3195

If you don't want to pass Class type as a parameter as mentioned by Mark Peters, you can use the following code. Kudos to David O'Meara.

  Class<T> type = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass())
                  .getActualTypeArguments()[0];
  if (type.isInstance(obj)) {
      ...
  }

Upvotes: 15

Puce
Puce

Reputation: 38132

To extend the sample of Mark Peters, often you want to do something like:

Class<T> type; //maybe passed to the method
if ( type.isInstance(obj) ) {
   T t = type.cast(obj);
   // ...
}

Upvotes: 27

Georgios Syngouroglou
Georgios Syngouroglou

Reputation: 19944

You could try this, 

// Cast your object to the generic type.
T data = null;
try {
    data = (T) obj;
} catch (ClassCastException cce) {
    // Log the error.
}

// Check if the cast completed successfully.
if(data != null) {
    // whatever....
}

Upvotes: 4

Ingo
Ingo

Reputation: 36339

This will only work (partly) if you have an object of type T. Then you can get the class of that object, see java.lang.Class<T> and find if it's the same as the object in question.

But note that this goes counter the very reason we have genrics: using a generic type is a way to say that you don't care what type it really is (up to upper and lower bounds that may be specified).

Upvotes: 1

Mark Peters
Mark Peters

Reputation: 81084

The only way you can do this check is if you have the Class object representing the type:

Class<T> type; //maybe passed into the method
if ( type.isInstance(obj) ) {
   //...
}

Upvotes: 151

Chris Dennett
Chris Dennett

Reputation: 22721

It would make more sense to put the restriction on where the type T is used to parametrise the Class type. When you pass the type in, instead of using something like Class<?>, you should use Class<? extends T>.

Upvotes: 3

Related Questions