1. 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.

2. Introduction THROWS an exception If an error occurs Java run-time environment

3. Pre-defined exception classes in Java Throwable NumberFormatException ArrayIndexOutOfBoundsException FileNotFoundException Exception Error RuntimeException IOException IllegalArgumentException IndexOutOfBoundsException

4. Checked and unchecked exceptions Java Compiler RuntimeException NumberFormatException IOException FileNotFoundException ERROR

5. Handling exceptions: an example 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.

6. Outline TestException class public class TestException { public static int getInteger() { // code for method goes here } }

7. The read method of System.in "hello" System.in.read( [ ] ) array of bytes 104,101,108, 111,13,10

8. 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); SSystem.in may throw a checked IOException

9. 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.

10. 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 } }

11. 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( );

12. 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

13. 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

14. 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);

15. 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. method throw Exception catch Exception

16. 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

17. Some methods of the Exception class methoddescription printStackTrace prints (onto the console) a stack trace of the exception toString returns a detailed error message getMessage returns a summary error message

18. 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"); } }

19. Test Run of ApititudeTest2 Enter aptitude test score:12w You entered an invalid number! Goodbye

20. 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"); }

21. 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; }

22. Exceptions in GUI applications room should be a number

23. 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.

24. Making use of exceptions: a first attempt public Bank(int sizeIn) throws NegativeArraySizeException { list = new BankAccount[sizeIn]; total = 0; }

25. 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; } }

26. 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

27. Creating your own exception classes public class NegativeSizeException extends Exception { public NegativeSizeException () { super("cannot set a negative size"); } public NegativeSizeException (String message) { super (message); } }

28. Amending the Bank constructor public Bank (int sizeIn) throws NegativeSizeException { if (sizeIn < 0) { throw new NegativeSizeException(); } else { list = new BankAccount[sizeIn]; total = 0; } }

29. 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 } }

30. Re-throwing exceptions public Bank (int sizeIn) throws NegativeSizeException { try { list = new BankAccount[sizeIn]; total = 0; } catch (NegativeArraySizeException e) { throw new NegativeSizeException (); } }

31. 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 NegativeSizeExceptionIf the collection is *sized with a negative *value */ public Bank (int sizeIn) throws NegativeSizeException { // as before }