The basic philosophy of Java is that badly formed code will not be run.
The ideal time to catch an error is at compile time, before you even try to run the program. However, not all errors can be detected at compile time. The rest of the problems must be handled at run time through some formality that allows the originator of the error to pass appropriate information to a recipient who will know how to handle the difficulty properly.
C and other earlier languages often had multiple error-handling schemes, and these were generally established by convention and not as part of the programming language. Typically, you returned a special value or set a flag, and the recipient was supposed to look at the value or the flag and determine that something was amiss. However, as the years passed, it was discovered that programmers who use a library tend to think of themselves as invincibleas in, Yes, errors might happen to others, but not in my code. So, not too surprisingly, they wouldnt check for the error conditions (and sometimes the error conditions were too silly to check for). If you were thorough enough to check for an error every time you called a method, your code could turn into an unreadable nightmare. Because programmers could still coax systems out of these languages, they were resistant to admitting the truth: that this approach to handling errors was a major limitation to creating large, robust, maintainable programs.
The solution is to take the casual nature out of error handling and to enforce formality. This actually has a long history, because implementations of exception handling go back to operating systems in the 1960s, and even to BASICs on error goto. But C++ exception handling was based on Ada, and Javas is based primarily on C++ (although it looks more like that in Object Pascal).
The word exception is meant in the sense of I take exception to that. At the point where the problem occurs, you might not know what to do with it, but you do know that you cant just continue on merrily; you must stop, and somebody, somewhere, must figure out what to do. But you dont have enough information in the current context to fix the problem. So you hand the problem out to a higher context where someone is qualified to make the proper decision (much like a chain of command).
The other rather significant benefit of exceptions is that they clean up error handling code. Instead of checking for a particular error and dealing with it at multiple places in your program, you no longer need to check at the point of the method call (since the exception will guarantee that someone catches it). And, you need to handle the problem in only one place, the so-called exception handler. This saves you code, and it separates the code that describes what you want to do from the code that is executed when things go awry. In general, reading, writing, and debugging code becomes much clearer with exceptions than when using the old way of error handling.
Because exception handling is the only official way that Java reports errors, and it is enforced by the Java compiler, there are only so many examples that can be written in this book without learning about exception handling. This chapter introduces you to the code you need to write to properly handle exceptions, and the way you can generate your own exceptions if one of your methods gets into trouble.
An exceptional condition is a problem that prevents the continuation of the method or scope that youre in. Its important to distinguish an exceptional condition from a normal problem, in which you have enough information in the current context to somehow cope with the difficulty. With an exceptional condition, you cannot continue processing because you dont have the information necessary to deal with the problem in the current context. All you can do is jump out of the current context and relegate that problem to a higher context. This is what happens when you throw an exception.
Division is a simple example. If youre about to divide by zero, its worth checking for that condition. But what does it mean that the denominator is zero? Maybe you know, in the context of the problem youre trying to solve in that particular method, how to deal with a zero denominator. But if its an unexpected value, you cant deal with it and so must throw an exception rather than continuing along that execution path.
When you throw an exception, several things happen. First, the exception object is created in the same way that any Java object is created: on the heap, with new. Then the current path of execution (the one you couldnt continue) is stopped and the reference for the exception object is ejected from the current context. At this point the exception handling mechanism takes over and begins to look for an appropriate place to continue executing the program. This appropriate place is the exception handler, whose job is to recover from the problem so the program can either try another tack or just continue.
As a simple example of throwing an exception, consider an object reference called t. Its possible that you might be passed a reference that hasnt been initialized, so you might want to check before trying to call a method using that object reference. You can send information about the error into a larger context by creating an object representing your information and throwing it out of your current context. This is called throwing an exception. Heres what it looks like:
if(t == null)
throw new NullPointerException();
This throws the exception, which allows youin the current contextto abdicate responsibility for thinking about the issue further. Its just magically handled somewhere else. Precisely where will be shown shortly.