Isn't there any way to find the class-type of a generic?
if (T instanceof String) {
// do something...
}
The above definitely does not compile.
4 Answers
Generics are a compile time feature. Generics add checks at compile time which may not have any meaning at runtime. This is one example. You can only check the type of the object referenced which could be a super type in code. If you want to pass the type T you have do this explicitly.
void someMethod(Class<T> tClass) {
if(String.class.isAssignableFrom(tClass))
or
void someMethod(Class<T> tClass, T tArg) {
Note: the type might not be the same,
someMethod(Number.class, 1);
7 Comments
mtyson
This is one of those answers that just nailed a bunch of things at once for me.
user25
what is this? e.g. I have
T var and how to use it with this method? someMethod(T) won't work... What I don't understand?
Peter Lawrey
@user25 I am not sure what you don't understand. Can you clarify what you mean? It sounds like a different question to me.
user25
@PeterLawrey stackoverflow.com/a/4704909/4548520 this works for me. This one I understood how to use: e.g I have
T var and then I have to check type like this: new Test<T>().something(var)Peter Lawrey
@user25 the only thing you can get here is the var.getClass () there is no way to get T if you do that.
|
It won't compile because T is not a variable, but a place holder for a class that is defined at runtime. Here's a quick sample:
public class Test<T> {
public void something(T arg) {
if (arg instanceof String) {
System.out.println("Woot!");
}
}
public static void main(String[] args) {
Test<String> t = new Test<String>();
t.something("Hello");
}
}
3 Comments
The Scrum Meister
I don't think that will work in java. see Jon Skeet's answer stackoverflow.com/questions/313584/…
gigadot
@The Scrum Meister , it works for this specific case. I have tested it.
William
This will work because you are using
instanceof to test against a known type, not a generic. What doesn't work is saying if (foo instanceof T) where foo is some variable, because the type that T represents is not known at compile time.if you have subclass
public class SomeClass extends SomeSubclass<String>{}
and
public class SomeSubclass<T> {}
then there is a way to discover type of T by executing code
Type t = getClass().getGenericSuperclass()
if (t instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType)t).getActualTypeArguments()
// in simple cases actualTypeArguments will contain Classes, since Class implements Type
}
if your case are a bit more complex (? extends String)` take a look at org.ormunit.entity.AEntityAccessor#extractClass
Comments
If you have specific field you can just check it like below:
private <T> String someMethod(T genericElement)
{
if (String.class.isInstance(genericElement))
{
return (String) genericElement;
}
...
Tis a type, not a variable. Only variables can be used on the left-hand side of theinstanceofoperator.