Transcript Catch

COMP201 Java Programming
Topic 7: Exceptions
Reading: Chapter 11
COMP201 Topic 7 / Slide 2
Outline

Introduction

Java exception classes

Dealing with exceptions

Throwing exceptions

Catching exceptions
COMP201 Topic 7 / Slide 3
Introduction

Causes of errors

User input errors:
typos, malformed URL, wrong file name, wrong info in file…

Hardware errors:
Disk full, printer out of paper or down, web page
unavailable…

Code errors:
invalid array index, bad cast, read past end of file, pop empty
stack, null object reference…
COMP201 Topic 7 / Slide 4
Introduction

Goals of error handling

Don’t want:

Want:

Return to a safe state and enable user to execute other
commands

Allow user to save work and terminate program gracefully.
COMP201 Topic 7 / Slide 5
Introduction

Java exception handling mechanism:

Every method is allowed to have two exit paths
No errors occur
– Method exits in the normal way
– Returns a value
– Control passed to the calling code.

If errors occur
– Method exits via an alternative exit path
– Throws an object that encapsulates the error information
– Control passed to exception mechanism that searches for an
appropriate exception handler to deal with the error condition
COMP201 Topic 7 / Slide 6
Throw & Catch an Exception




Exception object is created when an error occurs
Exception object contains information about the exception
The object is handed off to the runtime system
Runtime system searches for the method that contains an
appropriate exception handler
COMP201 Topic 7 / Slide 7
Advantage

Separate error handling code from regular code

Sample code without error handling
readFile {
open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
}

traditional error detection, reporting, and handling often lead
to messy code
Traditional Approach
errorCodeType readFile {
initialize errorCode = 0;
open the file;
if (theFileIsOpen) {
determine the length of the file;
if (gotTheFileLength) {
allocate that much memory;
if (gotEnoughMemory) {
read the file into memory;
if (readFailed) {
errorCode = -1;
}
} else {
errorCode = -2;
}
} else {
errorCode = -3;
}
close the file;
if (theFileDidntClose && errorCode == 0)
{
errorCode = -4;
} else {
errorCode = errorCode and -4;
}
} else {
errorCode = -5;
}
return errorCode;
}
Java Exception Handling Approach
readFile {
try {
open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
} catch (fileOpenFailed) {
doSomething;
} catch (sizeDeterminationFailed) {
doSomething;
} catch (memoryAllocationFailed) {
doSomething;
} catch (readFailed) {
doSomething;
} catch (fileCloseFailed) {
doSomething;
}
}
It does NOT spare your effort to detect,
report and handle the exception, but
provide an elegant framework.
COMP201 Topic 7 / Slide 9
Java Exception Class
JVM
internal
errors
COMP201 Topic 7 / Slide 10
Java Exception Classes

Java has many classes for error handling.
They are called exception classes
unchecked
java.lang.
Throwable
java.lang.LinkageError
java.lang.
Error
java.lang.
Exception
java.lang.VirtualMachineError
java.io.IOException
…
java.io.EOFException
java.lang.RuntimeException
unchecked
checked
java.lang.NullPointerException
java.lang.ClassCastException
java.lang.ArithmeticException
COMP201 Topic 7 / Slide 11
Unchecked exceptions


Error: For internal errors in JVM.
RuntimeException: Logical errors in
program (C++ logical-error).




Bad cast
Out-of-bound array access
Null reference access
Those two exceptions are unchecked
JVM internal errors beyond your control
 You should not allow logical errors at the first place

COMP201 Topic 7 / Slide 12
Checked exceptions

All other exceptions (C++ runtime_error) are checked, i.e.
you have to explicitly handle them. Otherwise compiler
errors results in.
Trying to read pass end of file
 Open a malform URL
 …
AclNotFoundException, ActivationException,
AWTException, BadLocationException,
ClassNotFoundException, CloneNotSupportedException,
DataFormatException, ExpandVetoException,
GeneralSecurityException, IllegalAccessException,
InstantiationException, InterruptedException,
IntrospectionException, InvocationTargetException,
IOException, LastOwnerException,
Can be found in online API
…

COMP201 Topic 7 / Slide 13
Java Exception Classes

You can define new Exception classes.
class FileFormatException extends IOException
{ // default constructor
public FileFormatException() {}
//constructor contains a detailed message
public FileFormatException(String message)
{ super( message );
}
New Exception class must be subclass of Throwable Most programs
throw and catch objects that derive from the Exception class
COMP201 Topic 7 / Slide 14
Dealing with Exceptions

Need to consider exceptions when writing each method

Identifying possible exceptions



Check the API of each method you use to see if it throws an
exceptions
Consider whether your own codes might produce exceptions.
Dealing with exceptions


Catching exceptions: Do this if you know how to handle an exception
in the current method.
Throwing exceptions: Do this if you don’t know how to handle an
exception in the current method and need the caller method to deal
with it.
The most important slide
COMP201 Topic 7 / Slide 15
Throwing Exceptions

Example: Consider reading Employee information from a
text file:

File format (employeeGood.dat)
3
Harry Hacker|37363.75|1989|10|1
Carl Cracker|78937.5|1987|12|15
Tony Tester|39995.0|1990|3|15

Some thing might go wrong (employeeBad.dat)
3
Harry Hacker|37363.75|1989|10|1
Carl Cracker|78937.5|1987|12|15
Tony Tester|39995.0|1990|3|
Missing one item here
COMP201 Topic 7 / Slide 16
Throwing Exceptions

Throw an exception generated by method call:
public void readData(BufferedReader in)throws IOException
{
String s = in.readLine();
StringTokenizer t = new StringTokenizer(s, "|");
name = t.nextToken();
salary = Double.parseDouble(t.nextToken());
int y = Integer.parseInt(t.nextToken());
int m = Integer.parseInt(t.nextToken());
int d = Integer.parseInt(t.nextToken());
GregorianCalendar calendar
= new GregorianCalendar(y, m - 1, d);
// GregorianCalendar uses 0 = January
hireDay = calendar.getTime();
}//DataFileTest.java
COMP201 Topic 7 / Slide 17
Throwing Exceptions

The method readLine of BufferedReader throws an
IOExpcetion. We do not deal with this exception in the
current method. So we state that the readData method
might throw IOException.

If you simply ignore it, compiler error results in. Try this.
COMP201 Topic 7 / Slide 18
Throwing Exceptions

The nextToken method might produce an
NoSuchElementException.

But this exception is unchecked, so we don’t have to worry
about it. No compiler errors result in because of this.

This leads to ungraceful behavior when exception is thrown
(Run ReadTextTest2 on employeeBad.dat)
COMP201 Topic 7 / Slide 19
Throwing Exceptions

Create and throw your own exception
public void readData(BufferedReader in)
throws IOException, FileFormatException
{ String s = in.readLine();
StringTokenizer t = new StringTokenizer(s, "|");
…
int d;
if (t.hasMoreTokens())
{
d = Integer.parseInt(t.nextToken()); }
else {
FileFormatException e = new FileFormatException
("Last item missing in:\n" + s +"\n" );
throw e;
}
…
} //ExceptionTest.java
COMP201 Topic 7 / Slide 20
Throwing Exceptions

Notes:

Can throw multiple types of exceptions
public void readData(BufferedReader in)
throws IOException, FileFormatException

Overriding method in subclass cannot throw more exceptions than
corresponding method in superclass
– If method in superclass does not throw any exceptions, overriding
method in subclass cannot either

Suppose method1 calls method2. If method2 throws
someException, method1 must
– Either catch someException
– Or declare someException in its header
COMP201 Topic 7 / Slide 21
Catching Exceptions

Catch exceptions with try/catch block
try
{ code
more code
}
catch( ExceptionType e)
{ handler for this exception
}

If a statement in the try block throws an exception



The remaining statements in the block are skipped
Handler code inside catch block executed.
If no exceptions are thrown by codes in the try
block, the catch block is skipped.
COMP201 Topic 7 / Slide 22
Catching Exceptions
public static void main(String[] args)
{ try
{ BufferedReader in = new BufferedReader(
new FileReader(args[0]));
Employee[] newStaff = readData(in);
…
}
catch(IOException exception)
{ exception.printStackTrace();
exit(0);
}} //ExceptionTest.java
 This code will exit right away with an error message if something goes
wrong in readData or in the constructor of FilerReader (an
IOException will be thrown)
COMP201 Topic 7 / Slide 23
Catching Exceptions

An more interesting exception handler
public void readData(BufferedReader in) throws IOException
{ String s = in.readLine();
StringTokenizer t = new StringTokenizer(s, "|");
…
int d;
try
{ d = Integer.parseInt(t.nextToken());
}
catch (NoSuchElementException e) {
String input = JOptionPane.showInputDialog
("Hire day for "+ name +"not available from file.\n“
+ "please provide from keyboard");
// convert string to integer value
d = Integer.parseInt(input);
…
}} //ExceptionTest1.java
COMP201 Topic 7 / Slide 24
Catching Multiple Exceptions

Can have multiple catchers for multiple types of exceptions:
public static void main(String[] args)
{ try
{ BufferedReader in = new BufferedReader(
new FileReader(args[0]));
Employee[] e = readData(in);
Might throw
…
ArrayIndexOutOfBoundsExpection
}
catch(IOException e1)
{ exception.printStackTrace();
}
catch(ArrayIndexOutOfBoundsException e2)
{ System.out.print("No file name provided " );
System.exit(1);
}
} // ExceptionTest2.java
COMP201 Topic 7 / Slide 25
Dealing with Exceptions

Example:
try {
average = total/count;
System.out.println(“Average is ” + average);
}
catch (ArithmeticException e) {
System.out.println(“Oops: ”+ e);
average = -1;}

If count is 0, this code will print out something like
“Oops: division by zero”.
COMP201 Topic 7 / Slide 26
Dealing with Exceptions

Can have multiple catchers for multiple types of exceptions:
try {…}
catch (ArithmeticException e1){…}
catch (IOException e2) {…}
catch (Exception e3) {…} //ANY exception
COMP201 Topic 7 / Slide 27
Catching Exceptions

Catchers can also re-throw an exception or throw
exception that is different from the exception caught.
graphics g = image.getGraphics();
try { …}
catch (MalformedURLException e)
{ g.dispose();
throw e;
}
We wish to dispose the graphics object g, but we don’t know how
to deal with the exception.
COMP201 Topic 7 / Slide 28
The finally clause
try
{ code
more code}
catch( ExceptionType e)
{ handler for this exception}
finally
{ .. }


The finally block is executed regardless
whether exceptions are thrown in the try block.
Useful in situations where resources must be
released no matter what happened
COMP201 Topic 7 / Slide 29
The finally clause

A caution about the finally clause:

Codes in the finally block are executed even there are return
statements in the try block
public static int f(int n)
{ try
{ return n* n;
}
finally
{ if ( n==2) return 0;
}
}
f(2) return 0 instead of 4!
COMP201 Topic 7 / Slide 30
Dealing with Exceptions

Search for handler: Steps:
– Tries to find a handler in the Catch block for the
current exception in the current method. Considers a
match If the thrown object can legally be assigned to the
exception handler’s argument.
– If not found, move to the caller of this method
– If not there, go another level upward, and so on.
(Reason for the last item on slide 20.)
– If no handler found, program terminates.
COMP201 Topic 7 / Slide 31
C++ Notes

Java exception handling similar to that of C++,
except:
– C++ enforces the throw specifier at run time, while
Java checks Throw specifier at compile time.
– In C++ a function can throw an exception in case of
no throw specification, while in Java a method
can only throw exceptions advertised.
– In C++ you can throw values of any type, while in
Java you can only throw objects of a subclass of
Throwable.