This snippet throws an NullPointerException
due to the fact that its unboxed to a primitive type and Long.longValue()
is called, right?
Thats even easy to see if you have a snippet like this:
long value = (Long) null;
But the NullPointerException
is even harder to get in a more complex situation like this:
long propertyValue = (Long) obj.getProperty(propertyModel.getName());
So isn't there any possibility for the Java-Compiler to make a more comfortable Exception out of this? I would prefer an IllegalArgumentException
with a message like "You're trying to cast a null-Object into a primitive type, this can't be done!"
Wouldn't this be more appropriate? What do you think? Is this even possible at runtime? Are we able to determine this cast? I haven't yet looked at the java bytecode. Maybe it could be used in a solution.
This question can be answered: I'd like to know if it's possible to achieve this behaviour!
According to the Java language specification, unboxing happens via calling Number.longValue()
, Number.intValue()
, etc. There is no special byte code magic happening, it's exactly the same as if you call those methods manually. Thus, the NullPointerException
is the natural result of unboxing a null
(and in fact mandated by the JLS).
Throwing a different exception would require checking for null
twice during every unboxing conversion (once to determine whether to throw the special exception, and once implicitly when the method is actually called). I suppose the language designers didn't think it useful enough to warrant that.