CMP2004

Advanced
Programming
LECTURE 6 EXCEPTION HANDLING
Errors in Programs
Golden rules of Programming
 Errors occur in all software programs

How to deal with errors

 Try to minimize their occurrence (bug checking)
 Data validation (prevent invalid data)
 Handle them as they occur

Errors can be dealt with at place error occurs

 Easy to see if proper error checking implemented
 Harder to read application itself and see how code works
Error handling (old way)
if (file exists) {
open file;
while (there is more records to be processed) {
if (no IO errors) {
process the file record
}
else {
handle the errors
}
}
if (file is opened)
close the file;
}
else {
report the file does not exist;
}
Sample Code
public static void main(String[] args) {
// TODO Auto-generated method stub

Scanner scanner = new Scanner(System.in);

System.out.print("Please enter an integer numerator: ");

int numerator = scanner.nextInt();

System.out.print("Please enter an integer denominator: ");

int denominator = scanner.nextInt();

int result = numerator / denominator;

System.out.printf("Result: %d / %d = %d%n", numerator, denominator,
result);
}
Output
Output
Output
Sample Code (Fix it)
...
int denominator = scanner.nextInt();
if(denominator!=0) {
int result = numerator / denominator;
System.out.printf("%nResult: %d / %d = %d%n",
numerator, denominator,
result);
}
else {
System.out.print("denominator must be nonzero ");
}
...
What is an Exception?
Definition: An exception or exceptional event is an event that occurs
during the execution of a program that disrupts the normal flow of
instructions
The following will cause exceptions
 Accessing an out-of-bounds array element
 Writing into a read-only file
 Trying to read beyond the end of a file
 Sending illegal arguments to a method
 Performing illegal arithmetic (e.g divide by 0)
 Hardware failures…
Exception Terminology
When an exception occurs, we say it was thrown or raised
When an exception is dealt with, we say it is handled or caught
The block of code that deals with exceptions is known as an exception
handler
Exception Handling
Makes clear, robust, fault-tolerant programs
Separates error handling code from "main line" of program
Deals with synchronous errors (i.e., Divide by zero)
Used when system can recover from error
Exception handler(recovery procedure)
 Typically used when error dealt with in different place than where it occurred
Exception Rules in JAVA
1. Exceptions must be Declared
public void methodReadFile(File source) throws FileNotFoundException;

2. Exceptions must be Handled

try {
methodReadFile (new File("test.in"));
// do something if no exception ...
// you main logic here in the try-block
} catch (FileNotFoundException ex) {
// error handling separated from the main logic
}
Exception Handling
Operations
Java’s exception handling consists of three operations:
 Declaring exceptions;
 Throwing an exception; and
 Catching an exception.
Declaring exceptions
A Java method must declare in its signature the types of exception it
may "throw" from its body, via the keyword "throws"

public void methodD() throws XException, YException

{
// method body throw XException and YException
}
Throwing an Exception
In case of an error create an appropriate Exception object and throw it

public void methodD() throws XException, YException { // method's signature

// method's body
...
...
// XException occurs
if ( ... )
throw new XException(...); // construct an XException object and
throw
...
// YException occurs
if ( ... )
throw new YException(...); // construct an YException object and
throw
...
}
Throwing an Exception
The throw statement requires a single argument: a throwable object
Throwable objects are instances of any subclass of the Throwable class
 Include all types of errors and exceptions
 Check the API for a full listing of throwable objects
Catching an Exception
try-catch block:
Enclose code that may generate an error in try block
Follow with one or more catch blocks
 Each catch block has an exception handler
 If exception occurs and matches parameter in catch block, code in catch
block executed
 If no exception thrown, exception handlers skipped and control resumes
after catch blocks
Format

try
{
// code that might throw exception
}
catch ([Type of Exception] e) {
// what to do if exception is thrown
}
Handling Multiple Exceptions
Handling multiple possible exceptions by multiple successive catch
blocks

try {
// code that might throw multiple
// exceptions
}
catch (XException e) {
// handle XException
}
catch (YException e2) {
// handle YException
}
Finally Block
The optional finally block at the end of the try-catch block
The finally block provides a mechanism to clean up regardless of what
happens within the try block
 Can be used to close files or to release other system resources
Finally Block
try
{
// code that might throw exception
}
catch ([Type of Exception] e) {
// what to do if exception is thrown
}
finally
{
// statements here always get executed
// regardless of code in the try block
}
Checked/Unchecked
Exceptions
Unchecked exceptions or runtime exceptions occur within the JVM
Examples of unchecked exceptions
 arithmetic exceptions (dividing by zero)
 pointer exceptions (trying to access an object’s members through a null
reference)
 indexing exceptions (trying to access an array element with an index that is
too large or too small)
 etc.

A method does not have to catch or specify that it throws unchecked

exceptions, although it may
Checked/Unchecked
Exceptions
Checked exceptions or compile time exceptions exceptions that occur
in
code outside of the Java runtime system
For example, exceptions that occur during I/O (covered next lecture)
are
checked exceptions
The compiler ensures that checked exceptions are caught or are
specified
to be thrown (using the throws keyword)
Handling Checked Exceptions
Every method must catch checked exceptions OR specify that it
may throw them (using the throws keyword)
Handling Checked Exceptions
void readFile(String filename) {
try {
FileReader reader = new FileReader("myfile.txt");
// read from file . . .
} catch (FileNotFoundException e) {
System.out.println("file was not found");
}
}

void readFile(String filename) throws FileNotFoundException {

FileReader reader = new FileReader("myfile.txt");
// read from file . . .
}
Writing Your Own Exceptions
There are at least 2 types of exception constructors:
 Default constructor: No arguments

NullPointerException e = new NullPointerException();

Constructor that has a detailed message: Has a single String argument
IllegalArgumentExceptione e =
new IllegalArgumentException("Number must be positive");
Writing Your Own Exceptions
Your own exceptions must be a subclass of the Exception class and have
at least the two standard constructors

public class MyCheckedException extends IOException {

public MyCheckedException() { }
public MyCheckedException(String m) {
super(m);
}
}
public class MyUncheckedException extends RuntimeException {
public MyUncheckedException() {}
public MyUncheckedException(String m) {
super(m);
}
}