Chapter 10: Exceptions and Advanced File I/O
IOException serves as a superclass for exceptions that are related to programming errors, such as an out-of-bounds array subscript.
False
The throws clause causes an exception to be thrown.
False
When an exception is thrown by code inside a try block, all of the state- ments in the try block are always executed.
False
When in the same try statement you are handling multiple excep- tions and some of the exceptions are related to each other through inheritance, you should handle the more general exception classes before the more specialized excep- tion classes.
False
You cannot have more than one catch clause per try statement.
False
Not including polymorphic references, a try statement can have only one catch clause for each specific type of exception.
True
When an exception is thrown, the JVM searches the try statement's catch clauses from top to bottom and passes control of the program to the first catch clause with a parameter that is compatible with the exception.
True
You are not required to catch exceptions that inherit from the RuntimeException class.
True
binary file
a file that contains binary data. storing data in its binary format is more efficient than storing it as text because there are fewer conversions to take place
concept 10.3
a file that contains raw binary data is known as a binary file. the content of a binary file is not formatted as text and not meant to be opened in a text editor. a random access file is a file that allows a program to read data from any location within the file, or write data to any location within the file. object serialization is the process of converting an object to a series of bytes and saving them to a file. deserialization is the process of reconstructing a serialized object
This is the process of converting an object to a series of bytes that represent the object's data. a. Serialization b. Deserialization c. Dynamic conversion d. Casting
a. Serialization
If your code does not handle an exception when it is thrown, it is dealt with by this. a. default exception handler b. the operating system c. system debugger d. default exception generator
a. default exception handler
This informs the compiler of the exceptions that could get thrown from a method. a. throws clause b. parameter list c. catch clause d. method return type
a. throws clause
You can think of this code as being "protected" because the application will not halt if it throws an exception. a. try block b. catch block c. finally block d. protected block
a. try block
note
all exception objects have a printStackTrace method, inherited from the Throwable class, that prints a stack trace.
checked exception
all of the remaining exceptions (that is, those that do not inherit from Error or RuntimeException). these are the exceptions that you should handle in your program
concept 10.1
an exception is an object that is generated as the result of an error or an unexpected event. to prevent exceptions from crashing your program, you must write code that detects and handles them
exception classes
an exception is an object. Exception objects are created from classes in the Java API
exception
an object that is generated in memory as the result of an error or an unexpected event. when an exception is generated, it is said to have been "thrown." unless an exception is detected by the application and dealt with, it causes the application to halt
unchecked exceptions
are those that inherit from the Error class or the RuntimeException class. recall that the exceptions that inherit from Error are thrown when a critical error occurs, such as running out of memory. you should not handle these exceptions because the conditions that cause them can rarely be dealt with in the program
FileNotFoundException inherits from a. Error b. IOException c. JavaException d. FileException
b. IOException
The numeric wrapper classes' "parse" methods all throw an exception of this type. a. ParseException b. NumberFormatException c. IOException d. BadNumberException
b. NumberFormatException
This is an internal list of all the methods that are currently executing. a. invocation list b. call stack c. call list d. list trace
b. call stack
When an exception is generated, it is said to have been a. built b. thrown c. caught d. killed
b. thrown
These are exceptions that inherit from the Error class or the RuntimeException class. a. unrecoverable exceptions b. unchecked exceptions c. recoverable exceptions d. checked exceptions
b. unchecked exceptions
This is a section of code that gracefully responds to exceptions. a. exception generator b. exception manipulator c. exception handler d. exception monitor
c. exception handler
This is one or more statements that are always executed after the try block has exe- cuted and after any catch blocks have executed if an exception was thrown. a. try block b. catch block c. finally block d. protected block
c. finally block
This method can be called from any exception object, and it shows the chain of meth- ods that were called when the exception was thrown. a. printInvocationList b. printCallStack c. printStackTrace d. printCallList
c. printStackTrace
You use this statement to manually throw an exception. a. try b. generate c. throw d. System.exit(0)
c. throw
catch clause
catch clause begins with the key word catch, followed by the code (ExceptionType ParameterName). this is a parameter variable declaration, where exceptionType is the name of an exception class and ParameterName is a variable name. if code in the try block throws an exception of the exceptionType class, then the parameter variable will reference the exception object
All exception classes inherit from this class. a. Error b. RuntimeException c. JavaException d. Throwable
d. Throwable
All exceptions that do not inherit from the Error class or the RuntimeException class are a. unrecoverable exceptions b. unchecked exceptions c. recoverable exceptions d. checked exceptions
d. checked exceptions
This method can be used to retrieve the error message from an exception object. a. errorMessage b. errorString c. getError d. getMessage
d. getMessage
note
don't confuse the throw statement with the throws clause. the throw statement causes an exception to be thrown. the throws clause informs the compiler that a method throws one or more exceptions
retrieving the default error message
each exception object has a method named getMessage that can be used to retrieve the default error message for the exception. this is the same message that is displayed when the exception is not handled and the application halts
warning
if the file that you are opening with the FileOutputStream object already exists, it will be erased and an empty file by the same name will be created
object serialization cont.
in order for an object to be serialized, its class must implement the Serializable interface. the Serializable interface, which is in the java.io package, has no methods or fields. it is used only to let the Java compiler know that objects of the class might be serialized. in addition, if a class contains objects of other classes as fields, those classes must also implement the serializable interface, in order to be serialized
stack trace
is a list of all the methods in the call stack. it indicates the method that was executing when an exception occurred and all of the methods that were called in order to execute that method
exception handler
is a section of code that gracefully responds to exceptions when they are thrown
call stack
is an internal list of all the methods that are currently executing.
try block
is one or more statements that are executed and can potentially throw an exception. You can think of the code in the try block as being "protected" because the application will not halt if the try block throws an exception
note
the FileOutputStream constructor throws an IOException if an error occurs when it attempts to open the file
default exception handler
the default exception handler prints an error message and crashes the program.
note
the exception classes are in packages in the Java API. for example, FileNotFoundException is in the java.io package. when you handle an exception that is not in the java.lang package, you will need the appropriate import statement
the finally clause
the try statement may have an optional finally clause, which must appear after all of the catch clauses. the statements in the finally block execute whether an exception occurs or not
object serialization
when an object is serialized, it is converted into a series of bytes that contain the object's data. if the object is set up properly, even the other objects that it might contain as fields are automatically serialized. the resulting set of bytes can be saved to a file for later retrieval
polymorphic references to exceptions
when handling exceptions, you can use a polymorphic reference as a parameter in the catch clause
concept 10.2
you can write code that throws one of the standard Java exceptions, or an instance of a custom exception class that you have designed
writing data to a binary file
you must create objects from the following classes: FileOutputStream, DataOutputStream you wrap a DataOutputStream object around a FileOutputStream object to write data to a binary file FileOutputStream fstream = new FileOutputStream("MyInfo.dat"); DataOutputStream outputFile = new DataOutputStream(fstream);
handling an exception
you use a try statement