9: Error Handling
with Exceptions

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. Feedback

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 invincible—as in, “Yes, errors might happen to others, but not in my code.” So, not too surprisingly, they wouldnrsquo;t check for the error conditions (and sometimes the error conditions were too silly to check for^[40]). 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. Feedback

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 BASICrsquo;s “on error goto.” But C exception handling was based on Ada, and Javarsquo;s is based primarily on C (although it looks more like that in Object Pascal). Feedback

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 canrsquo;t just continue on merrily; you must stop, and somebody, somewhere, must figure out what to do. But you donrsquo;t 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). Feedback

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. Feedback

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. Feedback

Basic exceptions

An exceptional condition is a problem that prevents the continuation of the method or scope that yoursquo;re in. Itrsquo;s 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 donrsquo;t 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. Feedback

Division is a simple example. If yoursquo;re about to divide by zero, itrsquo;s worth checking for that condition. But what does it mean that the denominator is zero? Maybe you know, in the context of the problem yoursquo;re trying to solve in that particular method, how to deal with a zero denominator. But if itrsquo;s an unexpected value, you canrsquo;t deal with it and so must throw an exception rather than continuing along that execution path. Feedback

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 couldnrsquo;t continue) is stopped and the reference for the exception object is ejected from t

剩余内容已隐藏，支付完成后下载完整资料

英语译文共 14 页，剩余内容已隐藏，支付完成后下载完整资料

资料编号：[613400]，资料为PDF文档或Word文档，PDF文档可免费转换为Word