JHTP小结_第十一章_深入理解异常（Exception Handling）

不知道为什么，这章的内容看起来很吃力。

本来以为自己的英语还不错，前面的几章看的挺顺溜，难道是因为前面几章的知识已经比较熟悉的缘故？->

Summary

Section 11.1Introduction

• An exception is anindication of a problem that occurs during a program’s execution.

• Exception handlingenables programmers to create applications that can resolve exceptions.

Section 11.2Example: Divide by Zero without Exception Handling

• Exceptions are thrown(p. 443) when a method detects a problem and is unable to handle it.

• An exception’s stacktrace (p. 444) includes the name of the exception in a message that indicates the problem that occurredand the complete method-call stack at the time the exception occurred.

• The point in theprogram at which an exception occurs is called the throw point (p. 445).

Section 11.3Example: Handling ArithmeticExceptions and InputMismatchExceptions

• A try block (p.447) encloses code that might throw an exception and codethat should not execute if that exception occurs.

• Exceptions may surfacethrough explicitly mentioned code in a try block,through calls to other methods or even throughdeeply nested method calls initiated by code in the try block.

• A catch block (p.448) begins with keyword catch and an exception parameter followed by a block of code that handles theexception. This code executes when the try block detectsthe exception.

• At least one catch block or a finally block (p.448) must immediately follow the try block.

• A catch blockspecifies in parentheses an exception parameter identifying the exception typeto handle. The parameter’sname enables the catch block to interact with a caught exception object.

• An uncaught exception(p. 449) is an exception that occurs for which there are no matching catch blocks. Anuncaught exception will cause a program to terminate early if that programcontains only one thread.Otherwise, only the thread in which the exception occurred will terminate.

The rest of the programwill run but possibly with adverse results.

• Multi-catch (p. 449)enables you to catch multiple exception types in a single catch handler and perform the same task foreach type of exception. The syntax for a multi-catch is:

catch (Type1 | Type2 | Type3 e)

• Each exception type isseparated from the next with a vertical bar (|).

• If an exception occursin a try block, the try block terminates immediately and program control transfers to the first catch block with aparameter type that matches the thrown exception’s type.

• After an exception ishandled, program control does not return to the throw point, because the try block has expired.This is known as the termination model of exception handling (p. 449).

• If there are multiplematching catch blocks when an exception occurs, only the first is executed.

• A throws clause (p.450) specifies a comma-separated list of exceptions that the method might throw, and appears afterthe method’s parameter list and before the method body.

Section 11.4 Whento Use Exception Handling

• Exception handlingprocesses synchronous errors (p. 451), which occur when a statement executes.

• Exception handling isnot designed to process problems associated with asynchronous events (p. 451), which occur inparallel with, and independent of, the program’s flow of control.

Section 11.5 JavaException Hierarchy

• All Java exceptionclasses inherit directly or indirectly from class Exception.

• Programmers can extendthe Java exception hierarchy with their own exception classes.

• Class Throwable is thesuperclass of class Exception and is therefore also the superclass of all exceptions. Only Throwable objects canbe used with the exception-handling mechanism.

• Class Throwable (p. 451) hastwo subclasses: Exception and Error.

• Class Exception and itssubclasses represent problems that could occur in a Java program and be caught by the application.

• Class Error and itssubclasses represent problems that could happen in the Java runtime system.

Errors happeninfrequently and typically should not be caught by an application.

• Java distinguishesbetween two categories of exceptions (p. 452): checked and unchecked.

• The Java compiler doesnot check to determine if an unchecked exception is caught or declared.

Unchecked exceptionstypically can be prevented by proper coding.

• Subclasses of RuntimeExceptionrepresent unchecked exceptions. All exception types that inherit from class Exception but not from RuntimeException(p. 452) are checked.

• If a catch block iswritten to catch exception objects of a superclass type, it can also catch allobjects of that class’ssubclasses. This allows for polymorphic processing of related exceptions.

Section 11.6 finallyBlock

• Programs that obtaincertain types of resources must return them to the system to avoid so-called resource leaks (p. 454).Resource-release code typically is placed in a finally block (p.454).

• The finally block isoptional. If it’s present, it’s placed after the last catch block.

• The finally block willexecute whether or not an exception is thrown in the corresponding try block or any of itscorresponding catch blocks.

• If an exception cannotbe caught by one of that try block’s associated catch handlers,control proceeds to the finally block. Thenthe exception is passed to the next outer try block.

• If a catch block throwsan exception, the finally block still executes. Then the exception is passed to the next outer try block.

• A throw statement (p.457) can throw any Throwable object.

• Exceptions are rethrown(p. 458) when a catch block, upon receiving an exception, decides either that it cannot processthat exception or that it can only partially process it. Rethrowing an exception defers theexception handling (or perhaps a portion of it) to another catch block.

• When a rethrow occurs,the next enclosing try block detects the rethrown exception, and that try block’s catch blocksattempt to handle it.

Section 11.7 StackUnwinding and Obtaining Information from an Exception Object

• When an exception isthrown but not caught in a particular scope, the method-call stack is unwound, and an attempt is made tocatch the exception in the next outer try statement.

• Class Throwable offers a printStackTracemethod that prints the method-call stack. Often, this is helpful in testing anddebugging.

• Class Throwable also providesa getStackTrace method that obtains the same stack-trace information that’s printed by printStackTrace(p. 461).

• Class Throwable’s getMessagemethod (p. 461) returns the descriptive string stored in anexception.

• Method getStackTrace(p. 461) obtains the stack-trace information as an array of StackTrace- Element objects. EachStackTraceElement represents one methodcall on the method-call stack.

• StackTraceElementmethods (p. 461) getClassName, getFileName, getLineNumberand get-MethodName get the classname, filename, line number and method name, respectively.

Section 11.8Chained Exceptions

• Chained exceptions (p.462) enable an exception object to maintain the complete stack-traceinformation, including informationabout previous exceptions that caused the current exception.

Section 11.9Declaring New Exception Types

• A new exception classmust extend an existing exception class to ensure that the class can be used with theexception-handling mechanism.

Section 11.10Preconditions and Postconditions

• A method’s precondition(p. 465) must be true when the method is invoked.

• A method’spostcondition (p. 465) is true after the method successfully returns.

• When designing your ownmethods, you should state the preconditions and postconditions in a comment before the methoddeclaration.

Section 11.11Assertions

• Assertions (p. 465)help catch potential bugs and identify possible logic errors.

• The assert statement (p.466) allows for validating assertions programmatically.

• To enable assertions atruntime, use the -ea switch when running the java command.

Section 11.12 try-with-Resources:Automatic Resource Deallocation

• The try-with-resourcesstatement (p. 467) simplifies writing code in which you obtain a resource, use it in a try block andrelease the resource in a corresponding finally block.Instead, you allocate the resource in theparentheses following the try keyword and use the resource in the try block; then the statementimplicitly calls the resource’s close method at the end of the try block.

• Each resource must bean object of a class that implements the AutoCloseable interface (p. 467)—such a class hasa close method.

• You can allocatemultiple resources in the parentheses following try by separatingthem with a semicolon (;).