Exception Handling

1. Exception Handling

2. You learned that there are three categories of errors: syntax errors, runtime errors, and logic errors. Syntaxerrors arise because the rules of the language have not been followed. They are detected by the compiler. Runtime errors occur while the program is running if the environment detects an operation that is impossible to carry out. Logic errors occur when a program doesn't perform the way it was intended to.

3. Exception Handling-Fundamentals • An exception is an abnormal condition that arises in a code sequence at run time • A Java exception is an object that describes an exceptional condition that has occurred in a piece of code • When an exceptional condition arises, an object representing that exception is created and thrown in themethod that caused the error • An exception can be caught to handle it or pass it on • Exceptions can be generated by the Java run-time system, or they can be manually generated by your code

4. Exception Handling • Performing action in response to exception • Examples • Exit program (abort) • Deal with exception and continue • Print error message • Request new data • Retry action

5. Representing Exceptions

6. Representing Exceptions • Java Exception class hierarchy ClassNotFoundException CloneNotSupportedException Exception IOException ArithmeticException AWTException NullPointerException RuntimeException IndexOutOfBoundsException Object Throwable … NoSuchElementException LinkageError … VirtualMachoneError Error AWTError Checked … Unchecked

7. System errors are thrown by JVM and represented in the Error class. The Error class describes internal system errors. Such errors rarely occur. If one does, there is little you can do beyond notifying the user and trying to terminate the program gracefully.

8. Exception describes errors caused by your program and external circumstances. These errors can be caught and handled by your program. • RuntimeException is caused by programming errors, such as bad casting, accessing an out-of-bounds array, and numeric errors.

9. Checked / Unchecked • RuntimeException, Error and their subclasses are known as uncheckedexceptions. All other exceptions are known as checked exceptions, meaning that the compiler forces the programmer to check and deal with the exceptions.

10. In most cases, unchecked exceptions reflect programming logic errors that are not recoverable. For example, a NullPointerException is thrown if you access an object through a reference variable before an object is assigned to it; an IndexOutOfBoundsException is thrown if you access an element in an array outside the bounds of the array.

11. These are the logic errors that should be corrected in the program. Unchecked exceptions can occur anywhere in the program. • To avoid cumbersome overuse of try-catch blocks, Java does not mandate you to write code to catch unchecked exceptions.

12. Exception Handling in Java • Java exception handling is managed by via five keywords: try, catch, throw, throws, andfinally • Program statements to monitor are contained within a try block • If an exception occurs within the try block, it isthrown • Code within catch block catch the exception and handle it

13. try { statements; // Statements that may throw exceptions } catch (Exception1 exVar1) { handler for exception1; } catch (Exception2 exVar2) { handler for exception2; } ... catch (ExceptionN exVar3) { handler for exceptionN; }

14. Example Output: Division by zero. After catch statement.

15. try and catch statement • The scope of a catch clause is restricted to those statements specified by the immediately preceding try statement. • A catch statement cannot catch an exception thrown by another try statement. • The statements that are protected by the try must be surrounded by curly braces.

16. Multiple Catch Clauses • If more than one can occur, then we use multiple catch clauses • When an exception is thrown, each catch statement is inspected in order, and the first one whose type matches that of the exception is executed • After one catch statement executes, the others are bypassed

17. Example

18. Caution • Exception subclass must come before any of of their superclasses • A catch statement that uses a superclass will catch exceptions of that type plus any of its subclasses. So, the subclass would never be reached if it come after its superclass • For example, ArithmeticException is a subclass of Exception • Moreover, unreachable code in Java generates error

19. Example

20. Nested try Statements • A try statement can be inside the block of another try • Each time a try statement is entered, the context of that exception is pushed on the stack • If an inner try statement does not have a catch, then the next try statement’s catch handlers are inspected for a match • If a method call within a try block has try block within it, then then it is still nested try

21. Example

22. throw • It is possible for your program to to throw an exception explicitly throw ThrowableInstance • Here, ThrowableInstance must be an object of type Throwable or a subclass Throwable • There are two ways to obtain a Throwable objects: • Using a parameter into a catch clause • Creating one with the new operator

23. Example -throw Statements Output: Caught inside demoproc. Recaught: java.lang.NullPointerException: demo

24. throws • If a method is capable of causing an exception that it does not handle, it must specify this behavior so that callers of the method can guard themselves against that exception • type method-name parameter-list) throws exception-list { // body of method } • It is not applicable for Error or RuntimeException, or any of their subclasses

25. Example: incorrect program

26. Example: corrected version Output: Inside throwOne. Caught java.lang.IllegalAccessException: demo

27. Finally Statement • finally creates a block of code that will be executed after a try/catch block has completed and before the code following the try/catch block. • finally block will be executed whether or not an exception is thrown. • Any time a method is about to return to the caller from inside a try/catch block, via an uncaught exception or an explicit return statement, the finally clause is also executed just before the method returns. • Each try clause requires at least one catch or finally clause.

28. animation Trace a Program Execution Suppose no exceptions in the statements try { statements; } catch(TheException ex) { handling ex; } finally { finalStatements; } Next statement;

29. animation Trace a Program Execution The final block is always executed try { statements; } catch(TheException ex) { handling ex; } finally { finalStatements; } Next statement;

30. animation Trace a Program Execution Next statement in the method is executed try { statements; } catch(TheException ex) { handling ex; } finally { finalStatements; } Next statement;

31. animation Trace a Program Execution Suppose an exception of type Exception1 is thrown in statement2 try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } finally { finalStatements; } Next statement;

32. animation Trace a Program Execution The exception is handled. try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } finally { finalStatements; } Next statement;

33. animation Trace a Program Execution The final block is always executed. try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } finally { finalStatements; } Next statement;

34. animation Trace a Program Execution The next statement in the method is now executed. try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } finally { finalStatements; } Next statement;

35. animation Trace a Program Execution statement2 throws an exception of type Exception2. try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } catch(Exception2 ex) { handling ex; throw ex; } finally { finalStatements; } Next statement;

36. animation Trace a Program Execution Handling exception try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } catch(Exception2 ex) { handling ex; throw ex; } finally { finalStatements; } Next statement;

37. animation Trace a Program Execution Execute the final block try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } catch(Exception2 ex) { handling ex; throw ex; } finally { finalStatements; } Next statement;

38. animation Trace a Program Execution Rethrow the exception and control is transferred to the caller try { statement1; statement2; statement3; } catch(Exception1 ex) { handling ex; } catch(Exception2 ex) { handling ex; throw ex; } finally { finalStatements; } Next statement;

39. Example

40. Output inside procA procA's finally Exception caught inside procB procB's finally inside procC procC's finally

41. class exc0{ public static void main(String args[]) { int d=0; int a=42/d; } } A new exception object is constructed and then thrown. This exception is caught by the default handler provided by the java runtime system. The default handler displays a string describing the exception, prints the stack trace from the point at which the exception occurred and terminates the program. Uncaught Exceptions Output: java.lang.ArithmeticException: / by zero at exc0.main(exc0.java:4)

42. When to Use Exceptions When should you use the try-catch block in the code? You should use it to deal with unexpected error conditions. Do not use it to deal with simple, expected situations. For example, the following code try { System.out.println(refVar.toString()); } catch (NullPointerException ex) { System.out.println("refVar is null"); }

43. When to Use Exceptions is better to be replaced by if (refVar != null) System.out.println(refVar.toString()); else System.out.println("refVar is null");

44. When to Throw Exceptions • An exception occurs in a method. If you want the exception to be processed by its caller, you should create an exception object and throw it. If you can handle the exception in the method where it occurs, there is no need to throw it.

45. Displaying a Description of an Exception • Throwable overrides the toString() method (defined by Object) so that it returns a string containing a description of the exception. • Example: catch(ArithmeticException e) { System.out.println(“Exception: “+e); } • Output: Exception: java.lang.ArithmeticException: / by zero

46. User Defined Exception • Define a subclass of the Exception class. • The new subclass inherits all the methods of Exception and can override them. class MyException extends Exception{ private int a; MyException(int i) { a = i;} public String toString (){ return “MyException[“ + a+”]”;} }

47. Continuation of the Example class test{ static void compute (int a) throws Myexception{ if(a>10) throw new MyException(a); System.out.println(“Normal Exit”); } public static void main(String args[]){ try{ compute(1); compute(20); }catch(MyException e){ System.out.println(“Caught “ +e); } }

48. Example-2 class InvalidRadiusException extends Exception { private double r; public InvalidRadiusException(double radius){ r = radius; } public void printError(){ System.out.println("Radius [" + r + "] is not valid"); } }

49. Continuation of Example-2 class Circle { double x, y, r; public Circle (double centreX, double centreY, double radius ) throws InvalidRadiusException { if (r <= 0 ) { throw new InvalidRadiusException(radius); } else { x = centreX ; y = centreY; r = radius; } } }

50. Continuation of Example-2 class CircleTest { public static void main(String[] args){ try{ Circle c1 = new Circle(10, 10, -1); System.out.println("Circle created"); } catch(InvalidRadiusException e) { e.printError(); } } }