Exceptions and Exception Handling Carl Alphonce CSE116 March 9, 2007
Exceptions andException Handling
Carl Alphonce
CSE116March 9, 2007
Intermediate Java
Topic overview Exceptions and exception handling
What are exceptions? When should you use exceptions? Details
How are exceptions generated (thrown)? How are exceptions handled (caught)? Runtime exceptions vs. other exceptions.
Collections What is a collection?
java.util.Collection interface Iterators
java.util.Iterator interface Iterator pattern Decoupling of data structure and iteration logic
Intermediate Java
What are exceptions? Exceptions are a mechanism for handling
“exceptional” situations which can occur at runtime.
Many languages provide exceptions. Terminology:
code where something unexpected happens “throws” an exception
code which handles the exceptional situation “catches” the exception – this code is called an exception handler
Intermediate Java
When are exceptions appropriate? Exceptions are appropriate to use to signal to a
caller a problematic situation which cannot be handled locally.
Example: Consider a file reading component which is used both by an interactive UI and a batch processing component. If the file reading component has a problem (e.g. “disk is full”), can it decide locally how to respond? No. It is up to the client to decide how to react. The UI may notify its human user. The batch processor may log the problem, and skip processing of this file.
Intermediate Java
When are exceptions not appropriate? It is not appropriate to use the exception
mechanism when an exceptional situation can be handled locally.
It is not appropriate to use the exception mechanism in dealing with situations which are not exceptional. If a particular situation is expected, it should be
explicitly checked for. For example, if a user supplies the name of a file to be
read, it is better to check for existence of the file rather than to attempt to read and rely on a thrown exception to give notice if the file doesn’t exist.
Intermediate Java
How are exceptions generated? An exception is an object An exception must derive from the
java.lang.Exception class Detour into inheritance and typing…
Intermediate Java
Types and subtypes Every class in Java defines a type. Every interface in Java defines a type. Types are arranged into a hierarchy:
classes can extend classes; interfaces can extends interfaces; classes can implement interfaces.
Every class except Object has a parent class (which is Object if no other parent is given): every other class has exactly one parent.
Intermediate Java
Hierarchy for Exceptions (partial) Object
Throwable Error
LinkageError ThreadDeath VirtualMachineError
Exception IOException
FileNotFoundException MalformedURLException
RuntimeException IndexOutOfBoundsException NullPointerException
Intermediate Java
Significance of hierarchy The type hierarchy is significant, not only
for exceptions, but for typing in Java more generally.
A variable declared to be of a given type can be assigned an object of that type, or of any subtype.
We make a distinction between the declared type of a variable, and the actual type of the object assigned to it.
Intermediate Java
How are exceptions generated? An exception is an object. An exception must derive from the
java.lang.Exception class. An exception object must be instantiated
from an exception class. new IndexOutOfBoundsException()
An exception must be thrown: throw new IndexOutOfBoundsException()
Intermediate Java
What happens when an exception is thrown? The exception is thrown until one of two
things happens: an exception handler for the thrown exception
is found, or the exception is uncaught (which typically
results in program termination). More technically, the runtime stack is
unwound until a handler is found or the stack is empty.
Intermediate Java
Runtime stack? Every time a method is called, an invocation
record is pushed onto the runtime stack. An invocation record stores things like:
parameter values local variables return value return location
When a method finishes, its corresponding invocation record is removed (“popped”) from the runtime stack.
Intermediate Java
Exceptions and flow-of-control When an exception is thrown, the regular
flow of control is interrupted. Invocation records are popped from
runtime stack until an exception handler is found.
Because of this, code in a method after a “throw” is not executed if the throw occurs.
Intermediate Java
Examplepublic int someMethod() { stmt1; stmt2; if (x<=0) { throw new Exception(); } stmt3; return x;}
Intermediate Java
Example (if x > 0)public int someMethod() { stmt1; stmt2; if (x<=0) { throw new Exception(); } stmt3; return x;}
Intermediate Java
Example (if x <= 0)public int someMethod() { stmt1; stmt2; if (x<=0) { throw new Exception(); } stmt3; return x;}
Intermediate Java
Catching an exception If you want to catch an exception, you
must indicate: from which segment of code you are prepared
to handle an exception which exception(s) you are going to handle
You can also: include a “cleanup” case to release resources
acquired, regardless of whether an exception was thrown
Intermediate Java
The try block To indicate the segment of code from
which you are prepared to handle an exception, place it in a try block:
stmt1;try { stmt2; stmt3;}stmt4;
Intermediate Java
A catch block A catch block is an exception handler for a
specific type of exception:
try { // code that may throw exception}catch (Exception e) { // code to handle exception}
Intermediate Java
Multiple catch blocks Can place many catch blocks (exception handlers) after a try
block:
try { // code that may throw exception}catch (IndexOutOfBoundsException e) { // code to handle an index out of bounds exception}catch (MalformedURLException e) { // code to handle a malformed URL exception}catch (Exception e) { // code to handle a general exception}
Intermediate Java
Recall there is an exception hierarchy: Here’s part of the hierarchy:
Exception IOException
FileNotFoundException MalformedURLException
RuntimeException IndexOutOfBoundsException NullPointerException
Intermediate Java
Catch block ordering: specific to general Catch blocks are tried in the order they are written:
try { // code that may throw exception}catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception}catch (RuntimeException e) { // code to handle runtime exception}catch (Exception e) { // code to handle any other exception}
Intermediate Java
Now consider a slightly different part of the hierarchy: Here’s part of the hierarchy:
Exception IOException
FileNotFoundException MalformedURLException
RuntimeException IndexOutOfBoundsException NullPointerException
Intermediate Java
Catch block ordering: general to specific? Catch blocks are tried in the order they are written:
try { // code that may throw exception}catch (Exception e) { // code to handle any exception}catch (RuntimeException e) { // code to handle a runtime exception // this is never reached!}catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception // this is never reached!}
Intermediate Java
Finally clause Optional Used to release resources back to OS
Shared resources are often acquired inside a try block (e.g. a file is opened for writing)
These resources must be released (e.g. the file must be closed so some other piece of code can use it):
if an exception is NOT thrown in the try block if an exception IS thrown in the try block
Intermediate Java
Flow of control:no exception is thrown
// some codetry { // code that may throw exception}catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception}catch (RuntimeException e) { // code to handle runtime exception}catch (MalformedURLException e) { // code to handle malformed URL exception}finally { // cleanup code}// more code
Intermediate Java
Flow of control:handled exception (e.g. RuntimeException) is thrown
// some codetry { // code that throws a RuntimeException}catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception}catch (RuntimeException e) { // code to handle runtime exception}catch (MalformedURLException e) { // code to handle malformed URL exception}finally { // cleanup code}// more code
Intermediate Java
Flow of control:unhandled exception (e.g. FileNotFoundException) is thrown
// some codetry { // code that throws a RuntimeException}catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception}catch (RuntimeException e) { // code to handle runtime exception}catch (MalformedURLException e) { // code to handle malformed URL exception}finally { // cleanup code}// more code
Intermediate Java
Defining your own exception classes Since exceptions are just objects derived
from the type java.util.Exception, you can define your own.
There are *many* predefined exceptions – one will likely meet your needs.
To define your own:
Intermediate Java
An example of an exception class
public class IllegalStateException extends RuntimeException { public IllegalStateException() { super(); } public IllegalStateException(String s) { super(s); } public IllegalStateException(String message, Throwable cause) { super(message, cause); } public IllegalStateException(Throwable cause) { super(cause); }}
Intermediate Java
Defining your own exceptions You generally only provide an appropriate
set of constructors. Rest of functionality is inherited.
Intermediate Java
Checked versus unchecked exceptions Java supports both checked and unchecked
exceptions. Checked exceptions are all exceptions
except those that derive from RuntimeException. These must be caught or declared in a method header's throws clause:
public void foo() throws ExcA, ExcB
where ExcA and ExcB are exception classes