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);
}
}