How do I check both 'instanceof' and also the Generic type of a Java object at runtime?

Question

How do I check both instanceof and isAssignableFrom of a Java object that uses generics?

If I have this method that checks instanceof only, BUT I also want to check that it returns a Boolean type as opposed to another type, how would I do this?

public void myMethod(ObjectA<Boolean> object)
{
    if ( object instanceof ObjectA ) {
       // then do something
    }
}

You most likely can't, since the type parameter would be erased at runtime. — nanofarad, Apr 28 '16 at 17:24
I don't understand. You already know at compile time that `object` is a `ObjectA`. This should already be enforced. — Sotirios Delimanolis, Apr 28 '16 at 17:31
You may want to take a look at this http://stackoverflow.com/questions/1901164/get-type-of-a-generic-parameter-in-java-with-reflection — Nadir, Apr 28 '16 at 18:08
@SotiriosDelimanolis Ok, so your saying I dont need to worry about someone writing code and passing in the wrong object because it will be caught by IDE code introspection before compile time? — djangofan, Apr 28 '16 at 18:23
Raw types are always an issue. But that's the client's issue, not yours. It's a misuse of your interface. A client shouldn't expect it to work when using raw types. — Sotirios Delimanolis, Apr 28 '16 at 18:25
And it's not the IDE, it's just the compiler. I can't call `myMethod(...)` with anything other than a value of type `ObjectA` (except if it's raw). — Sotirios Delimanolis, Apr 28 '16 at 18:26
And do you think my question is so obvious that it deserves closure rather than a formal answer? — djangofan, Apr 28 '16 at 18:32

score 0 · Accepted Answer · edited May 23 '17 at 11:52

In your example, the instanceof is unnecessary (unless you wanted to check for null, in which case you should just check for null with ==).

Your method declaration

public void myMethod(ObjectA<Boolean> object)

already enforces that callers can only pass values that are of type ObjectA<Boolean> or assignable to type ObjectA<Boolean>.

In other words, I cannot write code like

ObjectA<Integer> notBoolean = ...;
myMethod(notBoolean);

the compiler will reject it.

Within your method, since the parameter is of type ObjectA<Boolean>, the compiler guarantee is that nothing will get through at runtime that isn't an ObjectA. For example, you won't end up with object holding a reference to a Socket or a NoSuchElementException object.

The exception to all of the above is expressions having a raw type. Don't use raw types. Here's why:

What is a raw type and why shouldn't we use it?

With raw types, a client could potentially write

ObjectA<Integer> notBoolean = ...
ObjectA raw = notBoolean;
myMethod(raw);

and the compiler would forgo the generic type check and allow the invocation (the compiler erases the generic usage in the context of that invocation) .

Your code would presumably then fail at runtime with a ClassCastException when trying something like

public void myMethod(ObjectA<Boolean> object)
{
    Boolean ref = object.get(); // ClassCastException
                                // returns an `Integer` and attempts to assign it to a `Boolean` variable
}

Your object would still hold a reference to a ObjectA instance, but whatever it might wrap will no longer necessarily be a Boolean (I'm assuming ObjectA is some kind of wrapper for a Boolean value here).

This ClassCastException will be more or less equivalent to what you could've thrown anyway.

I wouldn't make a check specifically for this raw usage.

Thanks for your help on this. That all makes perfect sense. – djangofan Apr 28 '16 at 20:50 — djangofan, Apr 28 '16 at 20:50

How do I check both 'instanceof' and also the Generic type of a Java object at runtime?

1 Answers1