Exceptions and Exception Handling (2) Carl Alphonce CSE116

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()

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.

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.

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.

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

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

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

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

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;

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 }

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 }

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

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 }

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

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! }

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

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

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

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

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:

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); }

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