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