One of the most common problems that beginners run into (and some 'experts' though they can handle it i should hope) is the dreaded NullPointerException. One of the most frustrating things about the NPE is that it doesn't say what was null. All you get is a line number in the stack trace so if you're doing a lot on that line, it's not always clear. There are various ideas about how to clean that up in java 7. There are other solutions here and there as well so we'll see if any of that makes it into Java 7 or not. But we don't have Java 7 yet so none of that really helps. So here's my methodology/suggestions for dealing with them now. First, let's list why NPEs happen. That will help you find many NPEs just by looking at the code. The most common (and obvious to the seasoned developer) is that you didn't initialize a variable. Now, local variables must be initialized so the compiler helps you out a little there. However, instance and class fields do not so you'll need to be careful there. Also, you can silence the compiler complaints about uninitialized local variables by setting them to null. Obviously, if you don't reassign these references before trying to use them, you'll get an NPE. Another source is method return values. If you can't see the code being called, there's no real guarantee that you'll get a non-null reference back out of it. To be safe, all these values should be check for nulls before using them. Of course, your own methods might have bugs in them such that an null return might not be obvious. Or it might be intentional. In any case, you need to be mindful of the risks of using return values. Dealing with them is simple enough though apparently not that obvious to a beginner. As I mentioned earlier, the exact line is mentioned in the stack trace in the error logs or on the console. Given the discussion above, you can often spot the offending reference just by looking at that line of code. But if you do a lot of things one a line of code like I usually do, it can sometimes be less than obvious. The solution is simple enough here, too: break the line down into simpler bits. If you have chained method calls, for example, create local variables for each step and print out the results: foo.bar().bob(getDoug()).dude(getCar()); This becomes: System.out.println("foo = " + foo); Bar bar = foo.bar(); System.out.println("bar = " + bar); Doug doug = getDoug(); System.out.println("doug = " + doug); Bob bob = bar.bob(doug); System.out.println("bob = " + bob); We can essentially rule out the results of getCar() as that would result in an NPE on another line if that null gets passed into dude(). But this should be enough to highlight the exact value that is null. Once you correct that, you can recombine all that back into online if you like. There you go. NPE found and fixed. It's nothing fancy or complex. Just a little legwork to get you over the hump. This sort of thing becomes second nature to seasoned programmers but isn't always the most obvious to beginners. I hope it helps some of you on your way.
areudirty
kianamaiart
germansingergirl
ellievsbear
dailybridgerton
pixelskylines
yousharknotpass
origamiaround
