1. Exceptions

2. Many problems in code are handled when the code is compiled, but not all Some are impossible to catch before the program is run  Must run the program to actually determine the values of variables, get user input, etc. These errors that occur when the program is running are “exceptions”

3. 3 Exceptions An exception is an object that describes an unusual or erroneous situation Exceptions are generated by part of a program, and may be handled by another part of the program A program can be separated into a normal execution flow and an exception execution flow An error is also represented as an object in Java, but usually represents a unrecoverable situation and should not be caught

4. 4 Exception Handling Java has a predefined set of exceptions and errors that can occur during execution A program can deal with an exception in one of three ways:  ignore it  handle it where it occurs  handle it an another place in the program The manner in which an exception is processed is an important design consideration

5. Exception Handling If an exception isn’t handled by the program, it halts and prints an error: Exception in thread “main” java.lang.NullPointerException at SomeClass.method(SomeClass.java:54) at Except.e2(Except.java:12) at Except.main(Except.java:22) The error message gives the type of exception that was thrown ( NullPointerException ) and the “stack trace”…

6. 6 The Call Stack Trace Indicates the line on which the exception occurred  (SomeClass.java:54) Shows the method call trail that lead to the attempted execution of the offending line  main → e2 → method

7. Tracing Problems The call stack can be very long, and call methods in many libraries Exception in thread “main” java.util.UnknownFormatConversionException: Conversion = ‘i’ at java.util.Formatter$FormatSpecifier.conversion(Formatter.java:2603) at java.util.Formatter$FormatSpecifier. (Formatter.java:2631) at java.util.Formatter.parse(Formatter.java:2477) at java.util.Formatter.format(Formatter.java:2411) at java.io.PrintStream.format(PrintStream.java:899) at java.io.PrintStream.printf(PrintStream.java:800) at Except.e3(Except.java:17) at Except.main(Except.java:22) It can be tricky to find the “real” cause  should be the innermost code that isn’t fully tested

8. The Exception Class In Java, exceptions are objects There is a hierarchy of exception types, with Exception at the top  you don’t generally instantiate Exception ; one is automatically created when there is an error There are many subclasses of Exception that are used for particular types of errors

9. Exception Subclasses The subclasses of Exception are types that more specifically identify the problem, e.g.:  ArithmeticException most often caused by a divide-by-zero  IndexOutOfBoundsException array/List/String index doesn’t exist  NoClassDefFoundError.class file was there when compiling, but not there now Tend to have informative names: useful errors

10. 10 The Exception Class Hierarchy All error and exception classes are descendents of the Throwable class A programmer can define an exception by extending the Exception class or one of its descendants The parent class used depends on how the new exception will be used

11. Catching Exceptions We say that a certain block of code “throws” an exception  think: when the exception occurs, an exception object is generated and tossed at the interpreter How do you handle something that is thrown at the interpreter?  you “catch” it Uncaught exceptions stop the program… caught exceptions do not

12. 12 The try Statement To handle an exception in a program, the line that throws the exception is executed within a try block A try block is followed by one or more catch clauses Each catch clause has an associated exception type and is called an exception handler When an exception occurs, processing continues at the first catch clause that matches the exception type

13. A try/catch sequence try { \\ execute the code that you find here } catch(Exception e) { \\ if the there is an exception \\ then you do the stuff in this part }

14. An Example try { int x; x = 10/0; } catch(Exception e) { System.out.println(“error occurred”); }

15. The Exception Parameter The catch is a little like an else, and a little like a function definition  try {…} catch(Exception e) {…}  The argument (“exception parameter”) is assigned to an appropriate Exception object  In the divide-by-zero example, e will be an instance of ArithmeticException The exception parameter’s value can be ignored if you don’t need to use it

16. Another Example try { int x; x = 10/0; } catch(ArithmeticException e) { System.out.println(“divided by 0”); }

17. Being Specific Can have multiple catch blocks The exception parameter type allows different types of exceptions to be handled differently

18. Being Specific try { int x = userin.nextInt(); System.out.println(10/x); } catch(ArithmeticException e) { System.out.println(“no zeroes”); } catch(InputMismatchException e) { System.out.println(“enter a number”); } Most likely causes

19. Being Specific The exception parameter is matched like arguments in an overloaded function  The type of exception thrown is matched against the exception parameters  That class… or any subclass… will match Examples:  Exception matches all exceptions  IndexOutOfBounds matches both array and string exceptions

20. The Catch All try { … a bunch of code, involving an integer x… System.out.println(10/x); } catch(ArithmeticException e) { System.out.println(“no zeroes”); } catch(Exception e) { System.out.println(“some other problem”); }

21. However… In general, use a type as specific as possible  only catch the exceptions you want to catch and handle properly  Don’t incorrectly handle other problems the catch-all hides problems you might want to know about Other exceptions are propogated  they can be caught farther up the call stack

22. 22 Exception Propagation An exception can be handled at a higher level if it is not appropriate to handle it where it occurs Exceptions propagate up through the method calling hierarchy until they are caught and handled or until they reach the level of the main method A try block that contains a call to a method in which an exception is thrown can be used to catch that exception

23. Checked versus Unchecked An exception is either checked or unchecked An unchecked exception does not require explicit handling, though it could be processed that way The only unchecked exceptions in Java are objects of type RuntimeException or any of its descendants Errors are similar to RuntimeException and its descendants in that:  Errors should not be caught  Errors do not require a throws clause

24. 24 Checked Exceptions Checked exceptions (other subclasses of Exception ) must be handled explicitly  must be caught by a method in a catch block  must be listed in the throws clause of any method that might throw it The compiler will issue an error if a checked exception is not caught or asserted in a throws clause

25. The throws Clause Used to indicate that the method will “handle” the checked exception by passing it off to the calling code  Similarly, the calling code must either catch it or be declared indicating that it throws the exception public int myMethod() throws Exception1, Exception2 Any uncaught checked exceptions must be listed in the throws clause

26. The throw Statement When your code gets to a situation it can’t handle, it can throw an exception  e.g. constructor/setter given an illegal value Create an instance of the appropriate exception class  new SomeException(“Error message”); Throw the exception with a throw statement  throw new SomeException(“message”);

27. 27 The throw Statement The throw statement appears in the body of a method, with an appropriate throws clause Usually a throw statement is executed inside an if statement that evaluates a condition to see if the exception should be thrown if(x<0) throw new NegativeInputException;

28. Example From the Student class: public void setFirstName(String name) { if(name.length()>0) firstName = name; else throw new IllegalArgumentExceptionIllegalArgumentException (“Name must have length >0”); }

29. 29 The finally Clause A try statement can have an optional clause following the catch clauses, designated by the reserved word finally The statements in the finally clause always are executed If no exception is generated, the statements in the finally clause are executed after the statements in the try block complete If an exception is generated, the statements in the finally clause are executed after the statements in the appropriate catch clause complete

30. Why use finally ? To make sure that a certain part of an algorithm are executed To leave objects in a stable state  e.g. An object representing a database connection might be disconnected when an error occurs  … there are good security reasons for doing this