1. COP3502 Programming Fundamentals for CIS Majors 1 Instructor: Parisa Rashidi

2. -- Announcements

3.  Chapter 13  Exceptions  Exception handling  Declaring exception  Throwing exception  Catching exception  Different types of exceptions  Error vs. Exception  Checked vs. unchecked  Keywords  try, catch, finally  throw, throws Objectives

4.  When a program runs into a runtime error, the program terminates abnormally.  How can you handle the runtime error so that the program can continue to run or terminate gracefully? Motivation

5. Exceptions

6.  Show runtime error Program QuotientRun

7.  Fix it using an if statement Program QuotientWithIfRun

8.  Bonus Project  Up to 5 extra points  Exam  Cumulative (emphasis on later chapters)  Same format  You can bring a single sided page of notes  No larger than 8.5 x 11 (standard notebook)  Next week  Monday: Exception  Wednesday: Review  Friday: HW Review (by TA)  Course evaluation Announcements

9.  Exceptions  Motivation Previously

10.  What if the runtime error occurs in a called method? Program QuotientWithException Run

11.  The advantages of using exception handling:  It enables a method to throw an exception to its caller.  Without this capability, a method must handle the exception or  terminate the program. Program QuotientWithMethodRun

12.  By handling InputMismatchException, your program will continuously read an input until it is correct. Program InputMismatchRun

13.  Exception Types Exception Hierarchy

14.  “System errors” are thrown by JVM and represented in the Error class.  E.g. Linkage error, VirtualMachineError, …  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. Exception Hierarchy

15.  “Exception” describes errors caused by your program and external circumstances.  E.g. RuntimeException, IOException, ClassNotFoundException, …  These errors can be caught and handled by your program. Exception Hierarchy

16.  “RuntimeException” is caused by programming errors, such as bad casting, accessing an out-of-bounds array, and numeric errors.  E.g. ArithmaticException, NulPointerException, IndexOfBoundException, IllegalArgumentException,… Exception Hierarchy

17.  RuntimeException, Error and their subclasses are known as unchecked exceptions.  All other exceptions are known as checked exceptions, meaning that  the compiler forces the programmer to check and deal with the exceptions. Checked

18.  In most cases, unchecked exceptions reflect programming logic errors that are not recoverable.  E.g. NullPointerException or IndexOutOfBoundsException  To avoid cumbersome overuse of try-catch blocks, Java does not mandate you to write code to catch unchecked exceptions. Checked

19.  Exception handling process 1. Declare exception 2. Throw exception 3. Catch exception Exception Handling

20.  Every method must state the types of checked exceptions it might throw.  This is known as declaring exceptions. Declaring Exception

21.  When the program detects an error, the program can create an instance of an appropriate exception type and throw it.  This is known as throwing an exception. Throwing Exception

22.  Example Throwing Exception /** Set a new radius */ public void setRadius(double newRadius) throws IllegalArgumentException { if (newRadius >= 0) radius = newRadius; else throw new IllegalArgumentException( "Radius cannot be negative"); }

23.  Example Catching Exception

24.  Exception handling example Catching Exception

25.  Exceptions  Used in conjunction with methods  3 steps  Declare (throws)  Throw (throw)  Catch (try-catch)  Checked vs. unchecked Previously

26.  Java forces you to deal with checked exceptions.  IOException  If a method declares a checked exception you must 1. invoke it in a try-catch block or 2. declare to throw the exception in the calling method. Catching Exception

27.  For example, you have to write the code as shown in (a) or (b). Catching Exception

28.  The order in which exceptions are specified in catch blocks is important.  A compile error will result if a catch block for a superclass type appears before a catch block for a subclass type. Catching Exception

29.  This example demonstrates declaring, throwing, and catching exceptions by modifying the setRadius method in the Circle class.  The new setRadius method throws an exception if radius is negative. Program TestCircleWithException Run CircleWithException

30.  Rethrwoing exceptions Rethrow

31.  Occasionally, you may want some code to be executed regardless of whether an exception occurs or is caught. finally

32. Trace Program try { statements; } catch(TheException ex) { //handling ex; } finally { //finalStatements; } //Next statement.. Suppose no exceptions in the statements

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

34. Trace Program try { statements; } catch(TheException ex) { //handling ex; } finally { //finalStatements; } //Next statement.. Next statement in the method is executed

35. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program Suppose an exception of type Exception1 is thrown in statement2

36. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program The exception is handled.

37. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program The final block is always executed.

38. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program The next statement in the method is now executed.

39. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program statement2 throws an exception of type Exception2.

40. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program Handling exception

41. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program Execute the final block

42. try { statement1; statement2; statement3; } catch(Exception1 ex1) { //handling ex1; } catch(Exception2 ex2) { //handling ex2; throw x } finally { //finalStatements; } //Next statement.. Trace Program Rethrow the exception and control is transferred to the caller

43.  Exception handling separates error-handling code from normal programming tasks.  Thus making programs easier to read and to modify.  Be aware, however, that exception handling usually requires more time and resources because it requires  instantiating a new exception object,  rolling back the call stack, and  propagating the errors to the calling methods. Caution!

44.  When to use exceptions: 1. 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. When?

45.  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. When?

46.  Example When?

47.  Same example, better When?

48.  Use the exception classes in the API whenever possible.  Define custom exception classes if the predefined classes are not sufficient.  Define custom exception classes by extending Exception or a subclass of Exception. Custom Exceptions

49.  Custom Exception Program Run InvalidRadiusException CircleWithRadiusException TestCircleWithRadiusException