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.
31
Embed
Exceptions By the end of this lecture you should be able to: explain the term exception; distinguish between checked and unchecked exception classes in.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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;
public class AptitudeTest{ public static void main (String[] args) { int score; System.out.print("Enter aptitude test score: "); score = TestException.getInteger( ); // test score here }}
A program that allows a user to enter an aptitude test mark at the keyboard.
Outline TestException class
public class TestException{
public static int getInteger(){
// code for method goes here}
}
The read method of System.in
"hello"
System.in.read( [ ] )
array of bytes
104,101,108,108,111,13, 10
Coding the getInteger method
This is a first attempt, it will not compile!
byte [] buffer = new byte[512];
System.in.read(buffer);
String s = new String (buffer);
s = s.trim();
int num = Integer.parseInt(s);
return num;
System.in.read(buffer);
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
}
}
score = TestException.getInteger( );
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"); } }}
Fixing the problem
A test run
Enter aptitude test score:
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
12w
NumberFormatException
byte [] buffer = new byte[512];
System.in.read(buffer);
String s = new String (buffer);
s = s.trim();
int num = Integer.parseInt(s);
return num;
int num = Integer.parseInt(s);
Catching an 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.
methodthrow Exception
catch Exception
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 description
printStackTrace 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}