So I've run into this situation a million times in my "learning career" and I've always found a long way around the issue so as not to risk throwing unnecessary exceptions..
Let's look at a simple example...
boolean IsEnabled (JPanel MyPanel) {
return MyPanel.isEnabled();
}
Throws java.lang.NullPointerException if null is passed to the method.
So, I've learned to check if an object is null before checking with its methods.
boolean IsEnabled (JPanel MyPanel) {
if (MyPanel == null) return false;
else return MyPanel.isEnabled();
}
// OR
boolean IsEnabled (JPanel MyPanel) {
return (MyPanel == null) ? false : MyPanel.isEnabled();
}
Both work just fine, because MyPanel.isEnabled() is only called if MyPanel is not null. It's a more efficient alternative to wrapping MyPanel.isEnabled() in a try-catch statement. No exception should ever be thrown in the above case. The second method is simple, as all is contained in a single line, but is there anything simpler?
Today I saw something like the following snippet on the Internet:
boolean IsEnabled (JPanel MyPanel) {
return MyPanel != null && MyPanel.isEnabled();
}
It combines the null-check and the data-check on the same line, separated by a logical operator. In this example, the logic is AND. If MyPanel is null, the first part of the check returns false, and MyPanel.isEnabled() is not called and no exception is thrown, even though a NullPointerException should be thrown. I suppose the false before the && is reason enough for the processor not to bother checking with whatever is after the &&, am I right?
Switching the order of the check to
MyPanel.isEnabled() && MyPanel != null results in the exception. I guess what I'm trying to confirm is, has the JVM always given precedence to the first argument in a logical operation, and will it always ignore successive arguments given the first is reason enough to "call it quits"? I try my best to keep things organized, and often I'd
like to combine object checks into a single line at the beginning of a method call, just to be tidy. I think I've answered my own question by running the test above, but, should I feel safe in the future to combine null- and data-checks into a single logical statement without watching for exceptions?
