Exception Handling Yaodong Bi

Exception Handling Java exception handling Try blocks Throwing and re-throwing an exception Catching an exception Throws clause Exceptions in constructors and finalizers Exception and inheritance The finally block PrintStackTrace() and getMessage()

Java Exception Handling To process only exceptional situations where a method is unable to complete the task for reasons it cannot control To process exceptions from program components that are not geared to handling those exceptions directly To process exceptions from components such as libraries and classes that are likely to be widely used and where those components cannot handle their own exceptions

Java Exception Handling When an exception does not occur, little or no overhead is imposed by the presence of exception handling code. When exceptions occur, they do incur execution-time overhead Use Java’s standardized exception handling to improve program clarity and fault tolerance

Exception Handling Basics When a block of code (ex., a method) detects an error it cannot handle, it throws an exception The programmer encloses in a try block the code that may throw an exception. The try block is immediately followed by zero or more catch blocks to catch the exception(s) Each catch block specifies the type of exception it can catch and contains an exception handler An optional finally block (mandatory when no catch clause provided) will be executed regardless of whether or not there is an exception.

Exception Handling Basic A method can use a throws clause to specify what exceptions it may throw Java employs the termination model of exception handling. – Once an exception is thrown, the block in which the exception is thrown terminates and control cannot return to the throw point

Ex. 1: Divide By Zero public class ExceptionHandling { public static int quotient(int numerator, int denominator) throws DivideByZeroException { if (denominator == 0) throw new DivideByZeroException(); return numerator / denominator; } public static void main(String[] arg) { try { quotient(100, 0); } catch (DivideByZeroException e) { System.err.println(e.toString()); }

Ex. 1: Divide By Zero finally {System.out.println("Finally Block"); } // the following is saved in a separate file public class DivideByZeroException extends ArithmeticException { public DivideByZeroException() { super("Divide by Zero"); } public DivideByZeroException(String s) { super(s); }

Try blocks try { // code that may throw exceptions } catch (ExceptionType ref) { // exception handler } A try block can be followed by zero or more catch blocks If the try block executes with no exception thrown, all the exception handlers are skipped and control resumes with the first statement after the last exception handler If a finally block follows the last catch block, it will be executed regardless of whether or not an exception is thrown

Throwing Exceptions The throw statement makes an exception to occur – throwing an exception – throw new DivideByZeroException(); A throw statement must throw an object of any class derived from class Throwable When an exception is thrown, control exits the current try block and proceeds to an appropriate catch handler When toString() is invoked on any Throwable object, it returns the String that was supplied to the constructor public class DivideByZeroException extends ArithmeticException {public DivideByZeroException() {super("Divide by Zero"); // return by toString() }

Catching Exceptions Each catch block starts with the keyword catch followed by parentheses containing a class name (type of exception) The Exception object caught can be referred through the parameter catch (ExceptionType ref) { // using ref to refer to the exception object } It is possible that several handlers provide an acceptable match to the type of the exception, the first exception handler that matches the exception type is executed.

Catching Exceptions Each catch block defines a distinct scope An exception handler cannot access objects defined in other handlers Objects defined in a try block cannot be accessed in its exception handlers try { int tryX = 100; … } catch (ExceptionType1 ref) {int catch1Y = 200; // tryX is NOT accessible here } catch (ExceptionType2 ref) { // both tryX and catch1Y are NOT accessible here }

Catching Exceptions Exceptions thrown from a handler cannot be caught by the catch blocks of the current try-catch structure 1 try { 2try { throw new ExcType1(); } 3catch (ExcType1 ref) 4{ 5throw new ExcType2(); 6} 7catch (ExcType2 ref) 8{ 9 // this will NOT catch the ExcType2 thrown from line 5 10} 11 catch (ExcType2 ref) 12 { 13 // catch the ExcType2 exception thrown from line 5 14 }

Re-throwing Exceptions When a exception handler cannot or does not want to handle the caught exception completely, it can re-throw the exception using the throw statement. Such a re-thrown exception is handled by the enclosing try-catch block 1 try { 2try { throw new ExcType1(); } 3catch (ExcType1 ref) 4{ 5throw ref; 6} 7 catch (ExcType1 ref) 8 { 9 // catch the ExcType1 exception thrown from line 5 10 }

Throws Clause A throws clause lists the exceptions that can be thrown by a method void foo() throws ExceptionA, ExceptionB ExceptionA {// may throw the above three exceptions } All exceptions must be handled exception Error and RuntimeException If a method does not handle exceptions that may be thrown from its body, it must use the throws clause for the caller to handle the exceptions public void addCourse(String cid, String ttl) throws SQLException {… st.executeUpdate(sql); // may throw SQLException }

Java Exception Hierarchy ObjectErrorExceptionRuntimeExceptionThrowableAWTErrorLinkageErrorClassNotFoundExceptionNoSuchMethodExceptionArithmeticExceptionArrayStoreException Must be handled

Java Exception Hierarchy You can throw only objects that derive from the Throwable class. Errors: – When a "hard" failure in the virtual machine occurs, the virtual machine throws an Error. – Typical Java programs should not catch Errors and it's unlikely that typical Java programs will ever throw Errors either. Exceptions: – Most programs throw and catch objects that derive from the Exception class. – Exception has a special subclass RuntimeException which is not required to be handled

Runtime Exceptions The RuntimeException class represents exceptions that occur within the Java virtual machine (during runtime). – An example of a runtime exception is NullPointerException. The Java packages define several RuntimeException classes. You can catch these exceptions just like other exceptions. A method is not required to specify that it throws RuntimeExceptions. The cost of checking for all RuntimeExceptions often outweighs the benefit of catching it. the compiler allows RuntimeExceptions to go uncaught and unspecified.

Exception and Inheritance If a catch is written to catch exception objects of a superclass type, it can also catch all objects of subclasses of that superclass – catch (Exception e) { } would catch almost all exceptions This also allows for polymorphic processing of related exceptions It is a syntax error if a catch that catches a superclass object is placed before a catch that catches an object of a subclass of that superclass

The finally Block The finally block is optional; if it present it must be placed after the last catch block The finally block can be used to control resource leaks try { // may throw exceptions } catch (ExceptionType1 ref) { // exception handling statements } catch (ExceptionType2 ref) { // exception handling statements } finally { // statements // resource release statements }

The finally Block A finally block will be executed (if present) regardless of whether or not any exception is thrown and regardless of whether the exception is handled or not. – If there is no exception, it will be executed after the try block – If there is an exception and it is handled by a handler, it will be executed after the catch is completed – If there is an exception and it is not handled by a catch, it will be executed after the termination of the try block and then the exception is passed to to next level – If there is an exception in a catch block, it will be executed after the catch block terminates and then the exception is passed to next level

printStackTrace() and getMessage() Class Throwable offers a printStackTrace method that prints the method call stack Class Exception inherits the method Two constuctors for Exception public Exception() //accept no parameter public Exception(String str) // accept a string – The str stored in Exception may be queried with method getMessage()

printStackTrace & getMessage() public class ExceptionHandling {public static int quotient(int numerator, int denominator) throws DivideByZeroException {if (denominator == 0) throw new DivideByZeroException(); return numerator / denominator; } public static void main(String[] arg) { try { quotient(100, 0); } catch (DivideByZeroException e) { System.err.println(e.getMessage()); e.printStackTrace(); }

printStackTrace & getMessage() The following will be printed by the program – Printed by getMessage() Divide by Zero – Printed by printStackTrace() DivideByZeroException: Divide by Zero at ExceptionHandling.quotient(ExceptionHandling.java:7) at ExceptionHandling.main(ExceptionHandling.java:15)