Throwing and Catching Exceptions
When a program runs into a problem
that it cannot handle, it throws an
Exceptions are either caught (handled) or
Unhandled exceptions cause the
application to exit.
When Java encounters an unhandled
exception (e.g., divide by zero), the compiler
provides information that can help you find
the source of the error.
When an Exception is Thrown
Processing stops at point of exception.
Java Virtual Machine (JVM) looks for a
catch block to handle the exception.
JVM unwinds the stack, or retraces its
steps searching for a catch block.
If no catch block is found, the program
terminates with the default handler.
A try / catch block is the general
approach to exception handling.
The try block contains the code that
might throw an exception.
The catch block catches and handles the
exception, if thrown.
Use the throw keyword when throwing
if ( divisor == 0 )
throw new ArithmeticException();
All exceptions ultimately derive from
Throwable class, which is divided
into Error and Exception subclasses
Error exceptions are thrown by Java
system internal errors (e.g., “out of
Error exceptions are never thrown by
The Exception class is divided into
IOException and RunTimeException.
IOException problems are typically
beyond your control (e.g., the disk is full).
RunTimeException usually indicates a
programmer error (e.g., trying to write past
the end of an array).
Creating your own exception classes
allows you to throw more specific
Exceptions can be used polymorphically.
Multiple exception handling must be
coded in order from specific to more
An exception class derived from a more general
exception must be caught first.
The throws Keyword
A method can declare that it throws a
certain type of exception using the
“I am the readFile method and I might
throw an IOException.”
public void readFile(String
fileName) throws IOException
The finally Keyword
The finally keyword works in
conjunction with a try / catch block.
finally “cleans up” after an exception
Important to include finally block to
limit the chance of resource leaks due to
open connections or files