Exceptions and Exception Handling (2)

1. Exceptions andException Handling (2) Carl Alphonce CSE116

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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