Exception Handling

EXCEPTION HANDLING  Introduction  Exception – Indication that a problem occurred during program execution. – The problem occurs infrequently. – Exception examples • Out-of-bound array subscript (when an attempt is made to access an element past the end of an array) • Null pointer Exception in GUI (when a null reference is used where an object is expected, e.g., to add a GUI component that has not been created to a container).  • Arithmetic overflow, division by zero, memory exhaustion and invalid method parameters • Input mismatch exception Exception handling – Catch and handle errors (exceptions) rather than letting them occur and bear the consequences. – Improves the program's fault-tolerance and make it robust (programs that are able to deal with problems that may arise and continue executing). – Java support Exception handling (Enables programmer to deal with exception handling easily and resolve exceptions). – In languages that do not support exception handling, writing the error processing code is a considerable amount of programmer's effort and time. This way intermixing program logic with error handling logic. Make it less robust and difficult to read, modify, maintain and debug. – Java makes best to force the programmer to deal with error handling from the beginning of the project. – Java exception handling – similar to C++ – Throw an exception – a method which is unable to deal with a detected error throws (occurs) an exception. 2  Exception-Handling Overview  Uses of exception handling – Handle exceptions in a uniform manner in large projects. – Remove error-handling code from “main line” of execution – Improving program clarity and enhancing modifiability.  When exception occurs (exception are thrown and not caught) either : – Stack trace are displayed and the program will terminate. – Or the program may continue execution and the application may produce unexpected results (a program may have multithread (parallel activities), one may terminate and the remaining threads may continue execution).  Example: Divide By Zero Without Exception Handling  The following application divides two integer numbers without using exception handling. When exceptions are thrown (occur) the program does not handle them. // An application that attempts to divide by zero. import java.util.Scanner; public class Example1 { public static void main( String args[] ){ Scanner scanner = new Scanner( System.in ); System.out.print( "Please enter first number: " ); int num1 = scanner.nextInt(); System.out.print( "Please enter second number: " ); int num2 = scanner.nextInt(); int result = num1/num2; System.out.printf("\nResult: %d / %d = %d\n", num1,num2, result ); } } The Output 3  Stack trace: Several lines of information are displayed in response to error, which includes the name of the exception in a descriptive message that indicates the problem that occurred and the complete method-call stack (the call chain) at the time the exception occurred. The stack trace includes the path of the execution that led to the exception method by method (help in debug the program).  When division by zero in integer arithmetic occurs, Java throws an ArithmeticException (In java.lang).  When users make mistakes and input non integer values, Java throws an InputMismatchException (In java.util).  When an attempt is made to access an element past the end of an array, Java throws an ArrayIndexOutOfBoundsException (In java.lang).  When programmer try to access a null reference, Java throws an NullPointerException (In java.lang). 4  Structure and syntax of Java exception handling  Syntax template: try { statements that may generate exceptions } catch( ExceptionType exception1 ) { statements to process an exception } catch( AnotherExceptionType exception2 ) { statements to process an exception } ……… finally { statements resource release statements }  try block – Which encloses the code that may generate (throw) an exception and the code that should not execute if an exception occurs (if the exception occur, the remaining code in the try block will be skipped). – A try Block must be followed by at least one catch (or finally) block 5  catch block (or catch clause or exception handler) – catches (receives) and handles an exception (code that execute when the program detects an exception) – Each try block is followed by zero or more catch blocks. – A catch block begins with the keyword catch and is followed by a parameter in parentheses – Each catch block specifies the type of exception it can catch and contains exception handling code. When an exception is thrown, the program searches for the catch block that handles that specific type of exception (as shown in the parameter of the catch block) or a super class of that exception, and executes the statements in that block. – Exception handler – the method which handles (specifies) the recovery procedure. – Uncaught exception is an exception that occurs for which there are no matching catch block. It can force the termination of a program – catch( Throwable throwable) catches all exceptions AND errors (usually not used because errors are serious system problems that should not be caught) – catch ( Exception exception) – catches all exceptions – must be placed last in the list of catch blocks.  finally block (finally clause) – Provides code that is guaranteed to be always executed, regardless of whether exception occurred or not. – It is optional and appears after the last catch block if one exists. – Ideal location for resources releasing code (files, databases, network connections, etc. closing) to prevent resource leaking. – Finally block will execute if a try block exits by using return, break or continue. – The finally block will not be execute when a System.exit is executed in a try or catch block. 6  Example: Handling ArithmeticExceptions Only // An exception-handling example that checks for divide-by-zero import java.util.Scanner; public class Example2 { public static void main( String args[] ){ Scanner scanner = new Scanner( System.in ); try { System.out.print( "Please enter first number: " ); int num1 = scanner.nextInt(); System.out.print( "Please enter second number: " ); int num2 = scanner.nextInt(); int result = num1/num2; System.out.printf("\nResult: %d /%d = %d\n",num1,num2,result); } catch ( ArithmeticException e ){ System.out.println( "Zero is an invalid denominator. Please try again.\n"); } System.out.println("The End"); } } The output 7  Example: Handling ArithmeticExceptions and InputMismatchExceptions import java.util.InputMismatchException; import java.util.Scanner; public class Example3 { public static void main( String args[] ) { Scanner scanner = new Scanner( System.in ); try { System.out.print( "Please enter first number: " ); int num1 = scanner.nextInt(); System.out.print( "Please enter second number: " ); int num2 = scanner.nextInt(); int result = num1/num2; System.out.printf("\nResult: %d / %d = %d\n",num1,num2,result ); } catch ( ArithmeticException e1 ){ System.out.println("Arithmetic Exception\n"+ "Zero is an invalid denominator.Please try again.\n"); } catch ( InputMismatchException e ) { System.out.println("Input Mismatch Exception\n"+ "You must enter integers. Please try again.\n" ); } finally{ System.out.println("In Finally Block"); } System.out.println("The End"); } }  Example: Handling ArithmeticExceptions and InputMismatchExceptions (using looping statement) import java.util.*; public class Example4 { public static void main( String args[] ){ Scanner scanner = new Scanner( System.in ); boolean continueLoop = true; do { try { System.out.print("Please enter first number:"); int num1 = scanner.nextInt(); System.out.print("Please enter second number:"); int num2 = scanner.nextInt(); int result = num1/num2; System.out.printf("\nResult: %d /%d = %d\n",num1,num2,result); continueLoop = false; } catch ( ArithmeticException e) { 8 scanner.nextLine(); System.out.println("Arithmetic Exception\nPlease try again"); } catch ( InputMismatchException e ) { scanner.nextLine(); System.out.println("Input Mismatch Exception\n"+ "You must enter integers. Please try again.\n"); } } while ( continueLoop ); }} The output  Block scope caution – any variables/objects defined in any try/catch/finally blocks cannot be accessed by other blocks.  Try statement: consists of a try block and its corresponding catch and or finally blocks together.  Termination model of exception handling – The block in which the exception occurs expires and all the local variables declared in the block go out of scope and are destroy. – After the exception is handled, program control does not return to the throw point because the try block has expired. – Some languages use resumption model of exception handling (after an exception is handled, control resumes just after the throw point). 9  Notes: – No code should come between a try block and its corresponding catch blocks – Each catch block can have a single parameter only – It is a compilation error to catch the same exception type in more than one catch block, in the same try statement. – However there might be several catch blocks that match an exception (one matches the exact type and the other matches a superclass). In this case the first matching exception is executed. – You must place a catch block for the superclass after the catch blocks of individual subclasses. Otherwise the subclass catch block will not be executed (so compilation error will occur).  Java Exception Hierarchy  Throwable Class (Superclass) – Only classes that extend Throwable directly or indirectly can be used with exception handling.  Exception (SubClass of Throwable) – All java exception classes inherit directly or indirectly from class exception. – Class Exception and its sub classes represent Exceptional situations that can occur and caught by java program. –  Sub class from Exception IOException: – –  e.g. FileNotFoundException EOFException ( signals that an end of file has been reached unexpectedly during input) RuntimeException – e.g. ArrayIndexOutOfBoundsException, NullPointerException – InputMismatchException, ArithmeticException 10  Error (Subclass of Throwable) – Class Error and its subclass represent abnormal situation that could happen in JVM. – Errors happen infrequently and should not caught by program – E.g. AWTError, ThreadDeath, OutOfMemoryError (thrown when JVM can not allocate an object because it is out of memory, and no memory could be made available by garbage collector). Throwable Exception RuntimeException Error IOException AWTError ArrayIndexOutOfBoundsException ClassCastException  ThreadDeath OutOfMemoryError InputMismatchException NullPointerException ArithmeticException A program can catch (decide to handle): – All exceptions – All exceptions of a certain type – All exceptions of related types (inheritance hierarchy) 11 public class Example5 { public static void main( String args[] ) { int s1[] = new int[3]; for(int i=0; i<=2; i++) s1[i]=i; try { for(int i=0; i<=3;i++) System.out.println(s1[i] ); } catch ( ArithmeticException e1 ){ System.out.println("Handled in Arithmetic Exception catch"); } catch ( Exception e ) { System.out.println("Handled in Exception catch"); } } } The output public class Example6 { static int s1[]; public static void main( String args[] ) { try { method1(); } catch ( NullPointerException e1 ){ System.out.println("Handled in NullPointerException catch"); } catch ( Exception e ) { System.out.println("Handled in Exception catch"); } } public static void method1( ) { for(int i=0; i<=5;i++) System.out.println(s1[i] ); System.out.println("End Method1"); }} 12 The output  Two categories of exceptions  Checked exceptions – All classes that inherit from class IOException are checked exceptions – Java compiler enforces a catch-or-declare requirement – The compiler checks each method call and method declaration to determine whether the method throws checked exception. If so, the compiler ensures that the checked exception is caught or is declared in a throw clause. – Otherwise the compiler generates an error message indicating that the exception must be caught or declared.  Unchecked exceptions – All exception types that are direct or indirect subclasses of class RuntimeException – This includes ArrayIndexOutOfBoundsExceptions and ArithmeticExceptions – Classes that inherit from class Error are considered to be unchecked.  throws clause – Specifies the exceptions the method throws – Supplied at the method declaration, after the method parameter list. It lists the exceptions that can be thrown by the method, comma separated: public void fName(parameterList ) throws ExceptionType1, ExceptionType2, …{ //method body } – It used to indicate to the rest of the program that this method may throw that exception (make program more robust) – Exceptions listed in the throws clause are called checked exceptions. 13 public class Example7 { public static void main( String args[] ){ try { method1(); } catch ( Exception exception ) { System.out.println( "Exception handled in main" ); } finally{ System.out.println("Finally in main"); } } public static void method1() throws ArrayIndexOutOfBoundsException { int x[] = {1,2,3}; try { System.out.println( "In method1" ); for(int i = 0; i<=3 ; i++) System.out.println(x[i]); } catch ( ArrayIndexOutOfBoundsException e ) { System.out.println(e ); } finally { System.out.println( "Finally executed in method1" ); } System.out.println( "Method1 End" ); }} The output  Each Exception class has a toString() method which converts the exception description to a string that can be displayed as an error message. 14  Rethrowing an Exception – Rethrow exception if catch cannot handle it or if it can only partially process it. – Rethrowing an exception defers the exception handling to another catch block associated with an outer try statement  throw statement – used to indicate that exception has occurred. Consist of throw keyword followed by an Exception object to be thrown • – Example: throw new NullPointerException(); Exception Constructor Summary • Exception() : constructs a new exception with null as its details message. • Exception(String message) : constructs a new exception with the specified details message. – The following Java Application demonstrates that the finally block executes even if an exception is not thrown in the corresponding try block. public class Example8 { public static void main( String args[] ){ try { System.out.println( "In main method" ); throw new Exception(); } catch ( Exception e ) { System.out.println( e ) ; } finally { System.out.println( "Finally executed in main" ); } System.out.println( "main End" ); }} The output 15 // Demonstration of the try..catch...finally exception handling mechanism public class Example9 { public static void main( String args[] ) { try { throwException(); // call method throwException } // end try catch ( Exception exception ) { System.out.println( "Exception handled in main" ); } // end catch doesNotThrowException(); } // end main public static void throwException() throws Exception { try { System.out.println( "Method throwException" ); throw new NullPointerException(); // generate exception } // end try catch ( NullPointerException exception ){ System.out.println( "Exception handled in NullPointerException catch" ); throw new Exception(); // rethrow for further processing // any code here would not be reached } // end catch catch ( Exception exception ){ System.out.println( "Exception handled in Exception catch" ); } // end catch finally { System.out.println( "Finally executed in throwException"); } // end finally System.out.println("End of method throwException" ); // any code here would not be reached } // end method throwException public static void doesNotThrowException() { try { System.out.println( "Method doesNotThrowException" ); } // end try catch ( Exception exception ) { System.out.println( exception ); } // end catch finally{ System.out.println("Finally executed in doesNotThrowException"); } // end finally System.out.println("End of method doesNotThrowException" ); } // end method doesNotThrowException } // end class UsingExceptions – A catch block may catch (handle) one exception type, and then throws a new exception of a different type to indicate that a program-specific exception occurred. 16 The output  Notes: – Methods throwException and doesNotThrowException are declared static, so main can call them directly (i.e., without having to create an object of some class). – Avoid placing code that can throw an exception in a finally block. – Assuming that an exception thrown from a catch block will be processed by the catch block associated with the same try statement can lead to logic error.  Stack Unwinding – When an exception is thrown but not caught an in a particular scope (method), the methodcall stack is “unwound” and an attempt is made to catch the exception in the next outer try block. – When the exception not caught in scope: • Method terminates (all local variable in that method go out of scope and Control returns to the statement that invoked that method. • Stack unwinding occurs • Another attempt to catch exception. • If a try block encloses the call statement, an attempt is made to catch the exception. • If a try block does not enclose the call statement, stack unwinding occurs again. • If no catch block ever catches this exception and the exception is checked, then a compilation error occurs. 17  The following program demonstrates stack unwinding // Demonstration of stack unwinding. public class Example10 { public static void main( String args[] ) try { { throwException(); } // end try catch ( Exception exception ) { System.out.println( "Exception handled in main" ); } // end catch } // end main // throwException throws exception that is not caught in this method public static void throwException() throws Exception { try { System.out.println( "Method throwException" ); throw new Exception(); } // end try catch ( RuntimeException runtimeException ){ System.out.println("Exception handled in method throwException"); } // end catch finally { System.out.println( "Finally is always executed" ); } // end finally } // end method throwException } // end class UsingExceptions The output 18  Using nested try statements import java.util.*; public class Example11 { static int y,z; public static void main( String args[] ){ Scanner input= new Scanner(System.in); try { int x=input.nextInt(); try { System.out.println( "In try2" ); z=x/y; System.out.println(z); } catch ( ArithmeticException exception ) { System.out.println("Exception handled in try2" ); } finally { System.out.println( "Finally executed in try2" ); } } catch ( Exception exception ) { System.out.println( "Exception handled in try1" ); } finally { System.out.println( "Finally executed in try1" ); } }} The output 19 1 public class Example12 { 2 public static void main( String args[] ){ 3 try { 4 System.out.println("1"); 5 try { 6 System.out.println( "2" ); 7 throw new NullPointerException(); 8 } 9 catch ( ArithmeticException e ) { 10 System.out.println("3" ); 11 } 12 finally { 13 System.out.println( "4" ); 14 } 15 System.out.println("5"); 16 } 17 catch ( Exception e ) { 18 System.out.println( "6" ); 19 } 20 finally { 21 System.out.println( "7" ); 22 } 23 System.out.println("8"); 24 }} The output 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 public class Example13 { public static void main( String args[] ){ try { System.out.println("1"); int x = 4/(8-2*4); System.out.println("2"); try { System.out.println( "3" ); } catch ( ArithmeticException e ) { System.out.println("4" ); } finally { System.out.println( "5" ); } System.out.println("6"); } catch ( Exception e ) { System.out.println( "7" ); } finally { System.out.println( "8" ); } System.out.println("9"); }} The output 21 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 public class Example14 { public static void main( String args[] ){ try { method1(); } catch ( Exception exception ) { System.out.println( "Exception handled in main" ); } method2(); } public static void method1() { int x[] = {1,2,3}; try { System.out.println( "In method1" ); for(int i = 0; i<=3 ; i++) System.out.println(x[i]); } catch ( ArithmeticException exception ) { System.out.println("Exception handled in method1" ); } finally { System.out.println( "Finally executed in method1" ); } System.out.println( "Method1 End" ); } public static void method2() { try { System.out.println( "In Method2" ); } catch ( Exception exception ){ System.out.println( "Exception handled in method2" ); } finally { System.out.println("Finally executed in method2" ); } System.out.println( "End of method2" ); }} 22  Declaring New Exception Types – If someone else is going to use your class, then you may need to define new exception classes that are specific to the problems that can occur when another programmer uses your reusable classes. – A new exception class must extend an existing exception class to ensure that the class can be used with the exception-handling mechanism. – Like any other class it can contain fields and methods – But typically it contains only two constructors: • With no arguments, and passes a default exception message to the super class constructor. • With a string argument (the descriptive message) and passes it to the super class constructor. – You will need to decide whether your exception is checked or unchecked. – Example: public class NewException extends RuntimeException { // no-argument constructor public NewException() { . . } // one-argument constructor public NewException( String name ){ . . } } // end class NewException 23