1. Exceptions and Exception Handling Carl Alphonce CSE116

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.

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.