Exceptions

1. Exceptions • In this lecture: • What are exceptional situations in a program • How does one deal with them • The Java exception mechanism

2. What is an Exception? • An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. • Examples: • hard disk problem • accessing an out-of-bounds array element • passing an illegal argument to a method (clock example) • trying to invoke a method on a null pointer • division by zero • In all these cases we say that the program encountered a runtime error • The Java exception mechanism is designed to handle such situations

3. Example: The Clock Class Revisited • Consider the following code: Clock israelTime = new Clock(9,0,0); Clock losAngelesTime = new Clock(); losAngelesTime.setTime(israelTime.getHours() - 10,0,0); // oops… wrong value • We handled the situation by saying “if the clock programmer invokes the method with an illegal argument, then we ignore the call and the clock doesn’t change its value” • This prevents the clock from representing an illegal time value • BUT: this approach is an ideal source of bugs, since the programmer has no indication that an exception occurred!

4. Exception Handling Approaches • Bad approaches: • Display a message to the user • Don’t even attempt to detect an exception • Better approaches: • Return a value indicating an error occurred • Detect an exception, prevent it from being harmful • Even better approach: • When the programmer chooses not to deal with an exception, program execution ceases • The programmer always has the option of dealing with an exception

5. The Java Exception Mechanism • An exception object is created by the method in which the exception occurred, encapsulating information about the exception and state of program when it happened • This exception is handed (thrown) to the runtime system - Java interpreter - which attempts to find “someone” (a piece of code) to handle the exception (we will see how shortly) • If the appropriate “someone” to handle the exception is not found - the program terminates operation (“crashes”) with an appropriate message

6. Example 1 class ExceptionTest { public static void main(String[] args) { int[] ai = new int[4]; a[4] = 0; } } Output of program: java.lang.ArrayIndexOutOfBoundsException: 4 at ExceptionTest.main(ExceptionTest.java:3)

7. Example 2 class NullPointerTest { public static void main(String[] args) { String str = null; Sting str1 = str.toLowerCase(); } } Output of program: java.lang.NullPointerException: 4 at NullPointerTest.main(NullPointerTest.java:3)

8. Catching an Exception • A programmer may decide to deal with the situation by catching the exception, if it occurs • This is done using a “try…catch” clause: try { do dangerous operations which might throw exceptions } catch an exception { do whatever it takes to handle the exception } Exception Handler

9. Catching an Exception class ExceptionTest { public static void main(String[] args) { int[] ai = new int[4]; try { a[4] = 0; } catch (ArrayIndexOutOfBoundsException e) { System.out.println(“Array index problem:”); System.out.println(e); } } }

10. Types of Exceptions • Java defines many types of exceptions which might occur during program flow. Some of them are: • IllegalArgumentException - Passing an illegal argument to a method. Example: Math.pow(0,0) • NullPointerException • ArrayIndexOutOfBoundsException • ArithmeticException - Division by zero • StringIndexOutOfBoundsException • Of course, requiring the programmer to catch every out-of-bound array reference is horrifying and absurd, but: • there are other types of exceptions which must be dealt with • the programmer must have the ability to catch any exception it wishes (e.g, for debugging purposes)

11. Throwing Your Own Exception /** * Sets the time read by the clock. * @param hours The hours to be set (0-23) * @param minutes The minutes to be set (0-59) * @param seconds The seconds to be set (0-59) * @exception IllegalArgumentException if one of the * parameters is not in the * allowed range. */ public void setTime(int hours, int minutes, int seconds) { if ((seconds >= 0) && … && (hours < 24)) { this.hours = hours; this.minutes = minutes; this.seconds = seconds; } else throw new IllegalArgumentException("Clock arguments invalid"); }

13. Clock arguments must be correct! Clock: The Right Way public class ClockTest { public static void main(String[] args) { Clock c = new Clock(); try { c.setTime(50,50,50); } catch(IllegalArgumentException e) { System.out.println(e); e.printStackTrace(); } } } Output: java.lang.IllegalArgumentException: Clock arguments invalid at Clock.setTime(Clock.java:61) at ClockTest.main(ClockTest.java:5)

14. “Traditional” Error Handling • In traditional programming, error detection, reporting, and handling often lead to confusing spaghetti code. • Example: readFile { open the file; determine its size; allocate that much memory; read the file into memory; close the file; }

15. What is the Problem? • At first glance this function seems simple enough, but it ignores all of these potential errors: • What happens if the file can't be opened? • What happens if the length of the file can't be determined? • What happens if enough memory can't be allocated? • What happens if the read fails? • What happens if the file can't be closed?

16. Error Handling - The Old Way errorCodeType readFile { initialize errorCode = 0; open the file; if (theFileIsOpen) { determine the length of the file; if (gotTheFileLength) { allocate that much memory; if (gotEnoughMemory) { read the file into memory; if (readFailed) { errorCode = -1; } } else { errorCode = -2; } else { errorCode = -3; // etc. etc ...

17. Error Handling Using Exceptions readFile { try { open the file; determine its size; allocate that much memory; read the file into memory; close the file; } catch (fileOpenFailed) { doSomething; } catch (sizeDeterminationFailed) { doSomething; } catch (memoryAllocationFailed) { doSomething; } catch (readFailed) { doSomething; } catch (fileCloseFailed) { doSomething; } } main program flow exceptional situations

18. Propagating Errors Through Method Calls - The Old Way method1 { call method2; } method2 { call method3; } method3 { call readFile; }

19. Propagating Errors Through Method Calls - The Old Way method1 { errorCodeType error; error = call method2; if (error) doErrorProcessing; else proceed; } errorCodeType method2 { errorCodeType error; error = call method3; if (error) return error; else proceed; } errorCodeType method3 { errorCodeType error; error = call readFile; if (error) return error; else proceed; }

20. Exceptions: Propagation Up the Call Stack method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

21. method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

22. method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

23. method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

24. method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

25. method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

26. method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 { call method3; } method3 { call readFile; }

27. Runtime vs. Other Exceptions • By now, we’ve seen a special class of exceptions which is called Runtime Exceptions. • Some exceptions in Java must be caught explicitly, or else, the method in question must declare it is throwing an exception: public politicallyCorrectMethod { try { do something which may throw MustBeCaughtException; } catch (MustBeCaughtException e) { clear up the mess; } }

28. Runtime vs. Other Exceptions public ignorantMethod throws MustBeCaughtException{ do something which may throw MustBeCaughtException; // if it fails, the method who called // me (or the method who called it, etc.) // will clear up the mess... } • We will learn more about such exceptions in the future