1. Exceptions and Exception Handling Carl Alphonce CSE116 March 9, 2007

2. Intermediate Java Topic overview  Exceptions and exception handling What are exceptions? When should you use exceptions? Details  How are exceptions generated (thrown)?  How are exceptions handled (caught)?  Runtime exceptions vs. other exceptions.  Collections What is a collection?  java.util.Collection interface Iterators  java.util.Iterator interface  Iterator pattern  Decoupling of data structure and iteration logic

3. Intermediate Java What are exceptions?  Exceptions are a mechanism for handling “exceptional” situations which can occur at runtime.  Many languages provide exceptions.  Terminology: code where something unexpected happens “throws” an exception code which handles the exceptional situation “catches” the exception – this code is called an exception handler

4. Intermediate Java When are exceptions appropriate?  Exceptions are appropriate to use to signal to a caller a problematic situation which cannot be handled locally.  Example: Consider a file reading component which is used both by an interactive UI and a batch processing component. If the file reading component has a problem (e.g. “disk is full”), can it decide locally how to respond? No. It is up to the client to decide how to react. The UI may notify its human user. The batch processor may log the problem, and skip processing of this file.

5. Intermediate Java When are exceptions not appropriate?  It is not appropriate to use the exception mechanism when an exceptional situation can be handled locally.  It is not appropriate to use the exception mechanism in dealing with situations which are not exceptional. If a particular situation is expected, it should be explicitly checked for. For example, if a user supplies the name of a file to be read, it is better to check for existence of the file rather than to attempt to read and rely on a thrown exception to give notice if the file doesn’t exist.

6. Intermediate Java How are exceptions generated?  An exception is an object  An exception must derive from the java.lang.Exception class  Detour into inheritance and typing…

7. Intermediate Java Types and subtypes  Every class in Java defines a type.  Every interface in Java defines a type.  Types are arranged into a hierarchy: classes can extend classes; interfaces can extends interfaces; classes can implement interfaces.  Every class except Object has a parent class (which is Object if no other parent is given): every other class has exactly one parent.

8. Intermediate Java Hierarchy for Exceptions (partial)  Object Throwable  Error  LinkageError  ThreadDeath  VirtualMachineError  Exception  IOException  FileNotFoundException  MalformedURLException  RuntimeException  IndexOutOfBoundsException  NullPointerException

9. Intermediate Java Significance of hierarchy  The type hierarchy is significant, not only for exceptions, but for typing in Java more generally.  A variable declared to be of a given type can be assigned an object of that type, or of any subtype.  We make a distinction between the declared type of a variable, and the actual type of the object assigned to it.

10. Intermediate Java How are exceptions generated?  An exception is an object.  An exception must derive from the java.lang.Exception class.  An exception object must be instantiated from an exception class. new IndexOutOfBoundsException()  An exception must be thrown: throw new IndexOutOfBoundsException()

11. Intermediate Java What happens when an exception is thrown?  The exception is thrown until one of two things happens: an exception handler for the thrown exception is found, or the exception is uncaught (which typically results in program termination).  More technically, the runtime stack is unwound until a handler is found or the stack is empty.

12. Intermediate Java Runtime stack?  Every time a method is called, an invocation record is pushed onto the runtime stack.  An invocation record stores things like: parameter values local variables return value return location  When a method finishes, its corresponding invocation record is removed (“popped”) from the runtime stack.

13. Intermediate Java Exceptions and flow-of-control  When an exception is thrown, the regular flow of control is interrupted.  Invocation records are popped from runtime stack until an exception handler is found.  Because of this, code in a method after a “throw” is not executed if the throw occurs.

14. Intermediate Java Example public int someMethod() { stmt1; stmt2; if (x<=0) { throw new Exception(); } stmt3; return x; }

15. Intermediate Java Example (if x > 0) public int someMethod() { stmt1; stmt2; if (x<=0) { throw new Exception(); } stmt3; return x; }

16. Intermediate Java Example (if x <= 0) public int someMethod() { stmt1; stmt2; if (x<=0) { throw new Exception(); } stmt3; return x; }

17. Intermediate Java Catching an exception  If you want to catch an exception, you must indicate: from which segment of code you are prepared to handle an exception which exception(s) you are going to handle  You can also: include a “cleanup” case to release resources acquired, regardless of whether an exception was thrown

18. Intermediate Java The try block  To indicate the segment of code from which you are prepared to handle an exception, place it in a try block: stmt1; try { stmt2; stmt3; } stmt4;

19. Intermediate Java A catch block  A catch block is an exception handler for a specific type of exception: try { // code that may throw exception } catch (Exception e) { // code to handle exception }

20. Intermediate Java Multiple catch blocks  Can place many catch blocks (exception handlers) after a try block: try { // code that may throw exception } catch (IndexOutOfBoundsException e) { // code to handle an index out of bounds exception } catch (MalformedURLException e) { // code to handle a malformed URL exception } catch (Exception e) { // code to handle a general exception }

21. Intermediate Java Recall there is an exception hierarchy:  Here’s part of the hierarchy: Exception  IOException  FileNotFoundException  MalformedURLException  RuntimeException  IndexOutOfBoundsException  NullPointerException

22. Intermediate Java Catch block ordering: specific to general  Catch blocks are tried in the order they are written: try { // code that may throw exception } catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception } catch (RuntimeException e) { // code to handle runtime exception } catch (Exception e) { // code to handle any other exception }

23. Intermediate Java Now consider a slightly different part of the hierarchy:  Here’s part of the hierarchy: Exception  IOException  FileNotFoundException  MalformedURLException  RuntimeException  IndexOutOfBoundsException  NullPointerException

24. Intermediate Java Catch block ordering: general to specific?  Catch blocks are tried in the order they are written: try { // code that may throw exception } catch (Exception e) { // code to handle any exception } catch (RuntimeException e) { // code to handle a runtime exception // this is never reached! } catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception // this is never reached! }

25. Intermediate Java Finally clause  Optional  Used to release resources back to OS Shared resources are often acquired inside a try block (e.g. a file is opened for writing) These resources must be released (e.g. the file must be closed so some other piece of code can use it):  if an exception is NOT thrown in the try block  if an exception IS thrown in the try block

26. Intermediate Java Flow of control: no exception is thrown // some code try { // code that may throw exception } catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception } catch (RuntimeException e) { // code to handle runtime exception } catch (MalformedURLException e) { // code to handle malformed URL exception } finally { // cleanup code } // more code

27. Intermediate Java Flow of control: handled exception (e.g. RuntimeException) is thrown // some code try { // code that throws a RuntimeException } catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception } catch (RuntimeException e) { // code to handle runtime exception } catch (MalformedURLException e) { // code to handle malformed URL exception } finally { // cleanup code } // more code

28. Intermediate Java Flow of control: unhandled exception (e.g. FileNotFoundException) is thrown // some code try { // code that throws a RuntimeException } catch (IndexOutOfBoundsException e) { // code to handle index out of bounds exception } catch (RuntimeException e) { // code to handle runtime exception } catch (MalformedURLException e) { // code to handle malformed URL exception } finally { // cleanup code } // more code

29. Intermediate Java Defining your own exception classes  Since exceptions are just objects derived from the type java.util.Exception, you can define your own.  There are *many* predefined exceptions – one will likely meet your needs.  To define your own:

30. Intermediate Java An example of an exception class public class IllegalStateException extends RuntimeException { public IllegalStateException() { super(); } public IllegalStateException(String s) { super(s); } public IllegalStateException(String message, Throwable cause) { super(message, cause); } public IllegalStateException(Throwable cause) { super(cause); }

31. Intermediate Java Defining your own exceptions  You generally only provide an appropriate set of constructors.  Rest of functionality is inherited.

32. Intermediate Java Checked versus unchecked exceptions  Java supports both checked and unchecked exceptions.  Checked exceptions are all exceptions except those that derive from RuntimeException. These must be caught or declared in a method header's throws clause: public void foo() throws ExcA, ExcB  where ExcA and ExcB are exception classes