1. Joel Winstead http://www.cs.virginia.edu/~jaw2u
Lecture 9:
Exceptions in Java
CS201j: Engineering Software
University of Virginia
Computer Science
Joel Winstead

2. Menu What are exceptions? Declaring, using, and handling exceptions
Exceptions in specifications
Defensive Programming
26 September 2002
CS 201J Fall 2002

3. What is an exception? public class AverageLength {
public static void main String args[]) {
String filename = args[0]; … }
> javac AverageLength.java
> java AverageLength
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
at AverageLength.main(AverageLength.java:7)
26 September 2002
CS 201J Fall 2002

4. What happened?
We called the program with no arguments, so the args[] array is empty
We then tried to access args[0]
Does it make sense to ask for the first element of an empty array?
26 September 2002
CS 201J Fall 2002

5. Exceptions An exception indicates that something abnormal has happened
This could mean an error in the program
But not necessarily:
It could represent an undefined value of a method call
It could indicate some other special condition, such as FileNotFoundException
26 September 2002
CS 201J Fall 2002

6. Handling Exceptions
If an exception occurs, and we don’t do anything about it, the program stops.
This isn’t always what we want:
If there is an error, we may be able to fix it, report it, or degrade gracefully
If there is some other special condition, we may need to take note of this and continue processing
26 September 2002
CS 201J Fall 2002

7. Try and Catch The try clause indicates what to attempt to do
file = new FileReader(filename);
} catch (FileNotFoundException e) {
System.out.println(“Could not open “+filename);
System.exit(1); }
The try clause indicates what to attempt to do
The catch clause specifies:
An exceptional case
What to do if that exceptional case occurs
26 September 2002
CS 201J Fall 2002

8. Try and Catch If the try clause finishes normally
file = new FileReader(filename);
} catch (FileNotFoundException e) {
System.out.println(“Could not open “+filename);
System.exit(1); }
If the try clause finishes normally
The catch clause is ignored
If the try clause throws an exception,
The system looks for a matching catch clause
If one exists, it is executed, i.e. it handles the exception
26 September 2002
CS 201J Fall 2002

9. Throwing Exceptions
Some operations in Java generate exceptions automatically
We can also throw exceptions explicitly:
public float sqrt(float value) {
if (value < 0.0) {
throw new Exception(“Value is negative”);
} else {
... }
26 September 2002
CS 201J Fall 2002

10. Exception Propagation
public first_method() {
try {
second_method();
} catch (MyException e) {
System.out.println(
“A MyException occurred”); }
public second_method() {
try {
throw new MyException();
} catch (SomeOtherException e) {
System.out.println(
“An exception occurred”); }
What should happen here?
26 September 2002
CS 201J Fall 2002

11. Exception Propagation
public first_method() {
try {
second_method();
} catch (MyException e) {
System.out.println(
“A MyException occurred”); }
public second_method() {
try {
throw new MyException();
} catch (SomeOtherException e) {
System.out.println(
“An exception occurred”); }
first_method calls second_method
second_method throws a MyException
The catch clause in second_method does not match
The catch clause in first_method does match
The handler for MyException in first_method is executed to handle the exception
26 September 2002
CS 201J Fall 2002

12. Exception.printStackTrace()
When an exception occurs, we can call e.printStackTrace() to find out what happened:
try {
int a[] = new int[10];
a[17] = 1;
} catch (Exception e) {
System.err.println(e.toString());
e.printStackTrace(); }
java.lang.ArrayIndexOutOfBoundsException
at foo.main(foo.java:5)
26 September 2002
CS 201J Fall 2002

13. Declaring our own exceptions
We can also declare our own exception types:
public class MyException extends Exception { }
Why would we do this?
If a method is not defined for all cases, it makes sense to throw an exception rather than a meaningless value
It allows a program to indicate the nature of an error
It allows the program to indicate special, but non-error conditions
26 September 2002
CS 201J Fall 2002

14. Example class ElementNotFoundException extends Exception { }
class IntList {
int array[];
int n;
public int getElementIndex(int element)
throws ElementNotFoundException {
for (int i=0; i<array.length; i++) {
if (array[i] == element) {
return i; }
throw new ElementNotFoundException();
26 September 2002
CS 201J Fall 2002

15. Checked vs. Runtime Exceptions
Checked exceptions must be caught in a try..catch, or explicitly propagated:
public int getIndex(String element)
throws ElementNotFoundException {
... }
The Java compiler enforces this
Java does not require RuntimeExceptions to be declared, but it is a good idea
ESC/Java does require this
26 September 2002
CS 201J Fall 2002

16. Exception Type Hierarchy
Throwable
Error
Exception
RuntimeException
We can add our own exceptions to the hierarchy when we declare them:
class MyRuntimeException extends RuntimeException { }
26 September 2002
CS 201J Fall 2002

17. Generic Catch Clauses A catch clause can match subtypes of exceptions:
public class GeneralException extends Exception { }
public class SpecificException extends GeneralException { }
...
try {
throw new SpecificException();
} catch (GeneralException ge) {
ge.printStackTrace(); }
26 September 2002
CS 201J Fall 2002

18. Built-in Exception Types
Checked Exceptions:
FileNotFoundException
IOException
EndOfFileException
Runtime Exceptions:
ArrayIndexOutOfBoundsException
NullPointerException
26 September 2002
CS 201J Fall 2002

19. Exceptions in Abstractions
The exceptional behavior of a method is part of the abstraction it implements
The kinds of exceptions a method might throw, and what they mean, are just as important to understand as the normal return value
What could happen if we use a method, but don’t understand what exceptions it might throw, and don’t handle them?
26 September 2002
CS 201J Fall 2002

20. Unhandled Runtime Exceptions
The Ariane V
26 September 2002
CS 201J Fall 2002

21. Exceptions in Specifications
Java requires us to declare checked exceptions in a method’s throws clause
ESC/Java requires both checked and runtime exceptions to be declared
ESC/Java can be used to prove that certain runtime exceptions are not possible
ESC/Java annotations can be used to specify what should be true when an exception is thrown
26 September 2002
CS 201J Fall 2002

22. Proving Absence of Exceptions
public int getElementIndex(int array[],int element)
requires array != null {
for (int i=0; i<array.length; i++) {
if (array[element] == i) {
return i; }
Without this, ESC/Java issues a warning:
Warning: possible null dereference (Null)
for (int i=0; i < array.length; i++) { ^
26 September 2002
CS 201J Fall 2002

23. Defensive Programming
It is better to catch errors early
We can catch errors early if we add extra checks to the program for things that should not happen
We can use exceptions to do this
26 September 2002
CS 201J Fall 2002

24. Checking Requirements
We can verify the precondition of a method and throw an exception if it fails:
public int getIndex(int array[], int element)
throws PreconditionNotMetException
requires array != null
ensures array[\result] == element {
if (array == null) {
throw new PreconditionNotMetException(“array != null”);
} else {
... }
26 September 2002
CS 201J Fall 2002

25. Checking Invariants
We can also check a rep invariant and throw an exception if it fails:
public class IntList {
int array[];
int n;
invariant array != null && 0 <= n && n <= array.length
public void addElement(int new_element) {
if (array == null || n < 0 || n > array.length) {
throw new InvariantFailureException(); }
....
26 September 2002
CS 201J Fall 2002

26. Summary
Exceptions indicate abnormal or special conditions in a program
Exceptions propagate up the call chain until a matching handler is found
Exceptions are objects
Exceptional cases are part of the abstraction, and should be part of specifications
Exceptions can be used in defensive programming to catch mistakes early
26 September 2002
CS 201J Fall 2002

27. Charge
Coach Dave will have office hours on Friday from 3:30 to 4:30pm to give back design documents for PS4 and answer any questions about them
26 September 2002
CS 201J Fall 2002