Transcript CSE 501N Fall ‘06 02: Machine Overview + Fundamental Types

CSE 501N
Fall ’09
17: Exception Handling
03 November 2009
Nick Leidenfrost
Lecture Outline
Lab 6 Questions?
 Exceptions & Errors
 throws statement
 Exception Handling: try/catch blocks
 finally statement

2
Error Handling: Error Codes

Traditional approach:
 Method returns error code
public static final int NO_ERROR = 0;
public static final int BAD_INPUT = -1;
public static final int INVALID_STATE = -2;
// ...
public int doSomething (int someInput) {
if (!isValidInput(someInput))
return BAD_INPUT;
// ... Method body
return 0;
}
3
Error Handling: Error Codes

Problem: Caller is not forced to check for error code
 (Failure notification may go undetected)

Problem: Calling method may not be able to do
anything about failure
 Caller must also fail and let its caller worry about it
 Many method calls would need to be checked
 Lots of special logic would be introduced for
handling errors
4
Error Handling: Error Codes

Instead of programming for success:
int theAnswer = x.doSomething(0);

You would always be programming for
failure:
IntStorage answer = new IntStorage(0);
int errorCode = x.doSomething(0, answer);
if (errorCode != x.NO_ERROR) return errorCode;
5
Error Handling


Java provides two ways of dealing with
abnormal circumstances:
Exceptions
 “…
conditions that a … program might want to catch”
 Derived from java.lang.Exception

Errors
 “…
serious problems that a … program should not try
to catch”
 Derived from java.lang.Error
6
Throwing Exceptions

Exceptions:

Alter control flow to code intended to deal with the
problem:


Exception handlers
Can't be overlooked

Java compiler checks for existence of exception handlers

Throw an exception object to signal an exceptional
condition (or abnormal condition)

Method
execution is
Example:
IllegalArgumentException:
We throw
an
halted at this point and
exception with the
control flow is returned
throw
clause.
// illegal parameter
to the calling value
method.
Exception iaException
= new IllegalArgumentException(“Key cannot be null.");
throw iaException;
7
Throwing Exceptions

No need to store exception object in a
variable:
throw new IllegalArgumentException(“Key cannot be null.“);

When an exception is thrown, method
terminates immediately
 Execution
continues with an exception
handler which handles the type of exception
that was thrown
8
Example
public class HashMap {
public void put (Object key, Object value) {
if (key == null) {
IllegalArgumentException exception
= new IllegalArgumentException(“Key cannot
be null.“);
throw exception;
}
// ...
}
}
9
Types of Exceptions

Two types of exceptions:
 Checked

The compiler will check to make sure code exists
to handle the exception
 Unchecked
Usually arise in circumstances that would be
impossible for the compiler to predict
 A.k.a. Runtime exceptions
[ Eclipse Example ]

10
Hierarchy of Exception Classes
The Hierarchy of
Exception Classes
11
Checked vs. Unchecked Exceptions

Checked Exceptions
Usually due to external circumstances that the
programmer cannot prevent
 The compiler checks that you don't ignore them
outright



You must define exception handlers
Mainly occur when dealing with input and output

For example, IOException caused by File
manipulation, Networking, user input, etc.
12
Checked vs. Unchecked Exceptions

Unchecked Exceptions / Errors:
Extend the class RuntimeException or Error
 They are (usually) the programmer's fault
 Examples of runtime exceptions:

NullPointerException
ArrayIndexOutOfBoundsException
IllegalArgumentException

Example of error: OutOfMemoryError
13
Checked vs. Unchecked Exceptions

Categories aren't perfect:
 Scanner.nextInt throws unchecked
InputMismatchException
 Programmer cannot prevent users from entering
incorrect input
 This choice makes the class easy to use for
beginning programmers
[ Eclipse Scanner Example ]

Deal with checked exceptions principally when
programming with files and streams
 Coming up in a few lectures…
14
The throws clause


If an exception can be thrown, the compiler will
make sure our code acknowledges the exception
Two choices:
 Handle the exception in this method
 We’ll look at how to do this in a bit…
 Tell
compiler that you want method to be terminated
when the exception occurs

Use throws keyword to tell Java an exception may be
thrown inside the method body that is not handled
public void read(String filename) throws FileNotFoundException {
FileReader reader = new FileReader(filename);
Scanner in = new Scanner(reader);
. . .
}
15
The throws clause

For multiple exceptions:
public void read(String filename)
throws IOException, ClassNotFoundException

Keep in mind inheritance hierarchy:
If method can throw an IOException and
FileNotFoundException, only use IOException

Better to declare exception than to handle it
incompetently
16
Syntax: Exception Specification
accessSpecifier returnType
methodName(parameterType parameterName, . . .)
throws ExceptionClass, ExceptionClass, . . .
Example:
public void read(BufferedReader in) throws IOException
Purpose:
To indicate the checked exceptions that this method can throw
17
Exception Handlers
Catching Exceptions
Write exception handlers with the
try/catch statement
 try block contains statements that may
cause an exception
 catch clause contains handler for an
exception type

18
Catching Exceptions: Syntax
try {
// Code that might cause Exceptions
}
catch (Exception exception) {
// Code to handle Exceptions
}
19
Catching Exceptions: control flow
Statements in try block are executed
 If no exceptions occur, catch clauses are
skipped
 If exception of matching type occurs,
execution jumps to catch clause


If exception of another type occurs, it is
thrown until it is caught by another
try/catch block
20
Catching Exceptions: the catch clause
catch (IOException exception) {
}
 exception
contains reference to the
exception object that was thrown
 catch clause can analyze object to find out
more details
 exception.printStackTrace(): printout
of chain of method calls that lead to exception
21
Catching Errors: the catch clause

It is possible to catch Errors, also.
try {
...
}
catch (Error error) {
}

Because Errors are typically indicative of more
serious problems, doing this is rare.
 Most
often, the program is allowed to terminate.
22
Syntax: Multiple catch clauses
try {
//
//
}
catch
//
//
}
catch
//
//
}
statement
. . .
(ExceptionClass exceptionObject) {
statement
. . .
(ExceptionClass exceptionObject) {
statement
. . .
23
Catching Multiple Types of Exceptions
Throws
java.lang.IOException
try {
String filename = “. . .”;
FileReader reader = new FileReader(filename);
Scanner in = new Scanner(reader);
String input = in.next();
int value = Integer.parseInt(input);
. . .
Throws
}
java.lang.NumberFormatException
catch (Exception
(IOException
exception)
exception)
{ {
exception.printStackTrace();
}
catch (NumberFormatException exception) {
System.out.println("Input was not a number");
}
24
The finally clause

An uncaught exception terminates the
current method
-

! - This can skip over essential code
Example:
public void readSomeData () throws IOException {
FileReader reader =
Scanner input = new
readData(input);
reader.close(); //
new FileReader(filename);
Scanner(reader);
// Can throw an exception
May never get here
}
26
The finally clause

We want to execute reader.close()
even if an exception happens

Use finally clause for code that must
be executed "no matter what"
27
Example: The finally clause
FileReader reader = new FileReader(filename);
try {
Scanner in = new Scanner(reader);
readData(in);
}
catch (IOException ioe) {
// ...
}
finally {
reader.close(); // finally clause is executed regardless
// of whether exception occurs
}
28
Syntax: The finally clause
try {
// statements
}
finally {
// statements
}
// Notice that a try block can have a finally clause without a catch
// Why is this?
29
The finally clause

Executed when try block is exited in any of
three ways:
last statement of try block
 After last statement of catch clause, if this try block
caught an exception
 When an exception was thrown in try block and not
caught
 After

For any of these ways, the finally block
executes.
30
Designing Your Own Exception Types

You can design your own exception types–
subclasses of Exception or
RuntimeException
Unchecked
Exceptions
Checked
Exceptions
if (amount > balance) {
throw new InsufficientFundsException(
"withdrawal of " + amount + " exceeds balance of
“ + balance);
}
31
Designing Your Own Exception Types



Make it an unchecked exception–programmer
could have avoided it by calling getBalance
first
Extend RuntimeException or one of its
subclasses (InvalidParameterException)
Supply two constructors
1.
2.
Default constructor
A constructor that accepts a message string
describing reason for exception
32
Designing Your Own Exception
Types
public class InsufficientFundsException
public class InsufficientFundsException
extends RuntimeException {
extends RuntimeException {
public InsufficientFundsException() {}
public InsufficientFundsException() {}
}
}

public InsufficientFundsException (String message,
public InsufficientFundsException (String message) {
double shortage) {
super(message);
} super(message);
}
Your type can include additional
information needed to handle properly
33
Conclusion
Questions?
 Lab 6 Due Tonight at Midnight
 Lab 7 Assigned Today

 Due

11/10 at Midnight
Lab Now
34