Transcript Click here to lecture slides for week 3

Exceptions
By the end of this lecture you should be able to:
•
explain the term exception;
•
distinguish between checked and unchecked exception
classes in Java;
•
claim an exception using a throws clause
•
throw an exception using a throw command ;
•
catch an exception in a try catch block;
•
define and use your own exception classes.
Introduction
Java run-time
environment
If an error occurs
THROWS an
exception
Pre-defined exception classes in Java
Throwable
Exception
IOException
FileNotFoundException
Error
RuntimeException
IllegalArgumentException
NumberFormatException
IndexOutOfBoundsException
ArrayIndexOutOfBoundsException
Checked and unchecked exceptions
RuntimeException
IOException
Java
Compiler
NumberFormatException
FileNotFoundException
ERROR
Handling exceptions: an example
A program that allows a user to enter an aptitude test mark at the keyboard.
public class AptitudeTest
{
public static void main (String[] args)
{
int score;
System.out.print("Enter aptitude test score: ");
score = TestException.getInteger( );
// test score here
}
}
Outline TestException class
public class TestException
{
public static int getInteger()
{
// code for method goes here
}
}
The read method of System.in
array of bytes
System.in.read( [104,101,108,108,111,13, 10 ] )
"hello"
Coding the getInteger method
This is a first attempt, it will not compile!
byte [] buffer = new byte[512];
System.in.read(buffer);
System.in.read(buffer);
String s = new String (buffer);
s = s.trim();
int num = Integer.parseInt(s);
return num;
 System.in may throw a checked IOException
Dealing with exceptions
Whenever a method that throws a checked exception, the
Java compiler insists that we acknowledge this exception in
some way.
There are always two ways to deal with an exception:
1. Deal with the exception within the method by catching it;
2. Pass on the exception out of the method by claiming it.
Claiming an exception
Claiming an exception refers to a given method having been marked
to indicate that it will pass on an exception object that it might generate.
To claim an exception we add a throws clause to our method header :
import java.io.*
public class TestException
{
private static int getInteger( ) throws IOException
{
// as before
}
}
Revisiting the AptitudeTest class
public class AptitudeTest
{
public static void main (String[] args)
{
int score;
System.out.print("Enter aptitude test score: ");
score = TestException.getInteger( );
// test score here
}
}
Fixing the problem
import java.io.*;
public class AptitudeTest
{
public static void main (String[] args) throws IOException
{
int score;
System.out.print("Enter aptitude test score: ");
score = TestException.getInteger( );
if (score >= 50)
{
System.out.println("You have a place on the course!");
}
else
{
System.out.println("Sorry, you failed your test");
}
}
}
A test run
Enter aptitude test score: 12w
java.lang.NumberFormatException: 12w
at java.lang.Integer.parseInt(Integer.java:418)
at java.lang.Integer.parseInt(Integer.java:458)
at TestException.getInteger(TestException.java:10)
at AptitudeTest.main(AptitudeTest.java:11
NumberFormatException
byte [] buffer = new byte[512];
System.in.read(buffer);
String s = new String (buffer);
s = s.trim();
int
int num
num == Integer.parseInt(s);
Integer.parseInt(s);
return num;
Catching an exception
throw Exception
method
catch Exception
In order to trap the exception object in a catch block you must
surround the code that could generate the exception in a try block.
Syntax for using a try
and catch block
try
{
// code that could generate an exception
}
catch (Exception e)
{
// action to be taken when an exception occurs
}
// other instructions could be placed here
Some methods of the Exception class
method
printStackTrace
description
prints (onto the console) a stack trace of the exception
toString
returns a detailed error message
getMessage
returns a summary error message
import java.io.*;
public class AptitudeTest2
{
public static void main (String[] args)
{
try
{
// as before
score = TestException.getInteger( );
// as before
}
catch (NumberFormatException e)
{
System.out.println("You entered an invalid number!");
}
catch (IOException e)
{
System.out.println(e);
}
System.out.println("Goodbye");
}
}
Test Run of ApititudeTest2
Enter aptitude test score: 12w
You entered an invalid number!
Goodbye
import java.io.*;
public class AptitudeTest2
{
public static void main (String[] args)
{
try
{
// as before
score = TestException.getInteger( );
// as before
}
catch (NumberFormatException e)
{
System.out.println("You entered an invalid number!");
}
catch (IOException e)
{
System.out.println(e);
}
System.out.println("Goodbye");
}
}
import java.io.*
public class TestException
{
private static int getInteger( ) throws IOException
{
byte [] buffer = new byte[512];
System.in.read(buffer);
String s = new String (buffer);
s = s.trim();
int num = Integer.parseInt(s);
return num;
}
}
Exceptions in GUI applications
room should be a number
Using exceptions in your own classes
Look back at the Bank constructor:
public Bank(int sizeIn)
{
list = new BankAccount[sizeIn];
total = 0;
}
A negative value would not be a valid array size
This would cause an exception in the program;
The name of the exception is NegativeArraySizeException.
Making use of exceptions:
a first attempt
public Bank(int sizeIn)
throws NegativeArraySizeException
{
list = new BankAccount[sizeIn];
total = 0;
}
Making use of exceptions:
a second attempt
public Bank (int sizeIn) throws Exception
{
if (sizeIn < 0)
{
throw new Exception ("cannot set a negative size");
}
else
{
list = new BankAccount[sizeIn];
total = 0;
}
}
Testing for the exception
public class BankProgram
{
public static void main(String[] args)
{
try
{
System.out.print(“Maximum number of accounts? “);
size = EasyScanner.nextInt();
Bank myBank = new Bank(size);
// rest of code here
}
catch (Exception e)
{
System.out.println(e.getMessage());
}
}
// other static methods here as before
Creating your own exception classes
public class NegativeSizeException extends Exception
{
public NegativeSizeException ()
{
super("cannot set a negative size");
}
public NegativeSizeException (String message)
{
super (message);
}
}
Amending the Bank constructor
public Bank (int sizeIn) throws NegativeSizeException
{
if (sizeIn < 0)
{
throw new NegativeSizeException();
}
else
{
list = new BankAccount[sizeIn];
total = 0;
}
}
public class BankProgram
{
public static void main(String[] args)
{
try
{
System.out.print(“Maximum number of accounts? “);
size = EasyScanner.nextInt();
Bank myBank = new Bank(size);
// rest of code here
}
catch (NegativeSizeException e)
{
System.out.println(e.getMessage());
System.out.println(“due to error in Bank constructor”);
}
catch (Exception e)
{
System.out.println(“Some unforseen error”);
e.printStackTrace();
}
// other static methods here as before
}
}
Re-throwing exceptions
public Bank (int sizeIn)
throws NegativeSizeException
{
try
{
list = new BankAccount[sizeIn];
total = 0;
}
catch (NegativeArraySizeException e)
{
throw new NegativeSizeException ();
}
}
Documenting exceptions
/** Creates an empty collection of bank accounts
* and fixes the maximum size of this collection
*
* @param sizeIn
The maximum size of
*
the collection of bank
*
accounts
* @throws NegativeSizeException If the collection is
*
sized with a negative
*
value
*/
public Bank (int sizeIn) throws NegativeSizeException
{
// as before
}