Exception Handling

1. Exception Handling

2. Lecture Objectives • To learn how to throw exceptions • To be able to design your own exception classes • To understand the difference between checked and unchecked exceptions • To learn how to catch exceptions • To know when and where to catch an exception

3. The finally clause • Exception terminates current method • Danger: Can skip over essential code Example: reader = new FileReader(filename); Scanner in = new Scanner(reader); readData(in); reader.close(); // May never get here

4. The finally clause (Cont’d) • Must execute reader.close() even if exception happens • Use finallyclause for code that must be executed "no matter what"

5. The finally clause (Cont’d) FileReader reader = new FileReader(filename); try { Scanner in = new Scanner(reader); readData(in); } finally { reader.close(); // if an exception occurs, finally clause // is also executed before exception is // passed to its handler }

6. The finally clause (Cont’d) • Executed when try block is exited in any of three ways: • After last statement of try block • After last statement of catch clause, if this try block caught an exception • When an exception was thrown in try block and not caught • Recommendation: don't mix catch and finallyclauses in same try block

7. Syntax: The finally clause Try { statement statement . . . } finally { statement statement . . . }

8. Syntax: The finally clause (Cont’d) Example: FileReader reader = new FileReader(filename); try { readData(reader); } finally { reader.close(); } Purpose: To ensure that the statements in the finally clause are executed whether or not the statements in the try block throw an exception.

9. Designing Your Own Exception Types • You can design your own exception types–subclasses of Exception or RuntimeException • Make it an unchecked exception–programmer could have avoided it by calling the method getBalance() first if (amount > balance) { throw new InsufficientFundsException( " withdrawal of " + amount + " exceeds balance of " + balance); } Continued…

10. Designing Your Own Exception Types (Cont’d) • Extend RuntimeException or one of its subclasses • Supply two constructors • Default constructor • It is good practice to include a default message in the default constructor • A constructor that accepts a message string describing “current-object-info” and/or reason for exception

11. Designing Your Own Exception Types (Cont’d) public class InsufficientFundsException extends RuntimeException{ public InsufficientFundsException() { super("Insufficient Funds Exception"); } public InsufficientFundsException(String message) { super(message); } }

12. Using the getMessage Method • Every exception has a String instance variable that contains some message • This string typically identifies the reason for the exception • This is the string used for the value of the string instance variable • Therefore, the method call e.getMessage() returns this string

13. Using the getMessage Method . . . // method code try { . . . throw new InsufficientFundsException( " withdrawal of " + amount + " exceeds balance of " + balance); . . . } catch(InsufficientFundsException e) { String message = e.getMessage(); System.out.println(message); } . . .

14. Preserve getMessage • For all predefined exception classes, getMessage returns the string that is passed to its constructor as an argument • Or it will return a default string if no argument is used with the constructor • This behavior must be preserved in all programmer-defined exception class • A constructor must be included having a string parameter whose body begins with a call to super • The call to super must use the parameter as its argument • A no-argument constructor must also be included whose body begins with a call to super • This call to super must use a default string as its argument

15. The Method printStackTrace() • Used to determine the order in which the methods were called and where the exception was handled

16. The Method printStackTrace() (Cont’d) import java.io.*; public class PrintStackTraceExample1 { public static void main(String[] args) { try { methodA(); } catch (Exception e) { System.out.println(e.toString() + " caught in main"); e.printStackTrace(); } } Continued…

17. The Method printStackTrace() (Cont’d) public static void methodA() throws Exception { methodB(); } public static void methodB() throws Exception { methodC(); } public static void methodC() throws Exception { thrownew Exception("Exception generated " + "in method C"); } } Continued…

18. The Method printStackTrace() (Cont’d) • Sample Run: java.lang.Exception: Exception generated in method C caught in main java.lang.Exception: Exception generated in method C at PrintStackTraceExample1.methodC (PrintStackTraceExample1.java:30) at PrintStackTraceExample1.methodB (PrintStackTraceExample1.java:25) at PrintStackTraceExample1.methodA (PrintStackTraceExample1.java:20) at PrintStackTraceExample1.main (PrintStackTraceExample1.java:9)

19. Effective Design • Unfixable Error: If possible, it’s better to terminate the program abnormally than to allow the error to propagate. • Normal versus Exceptional Code: The exception handler --- the catch block --- is distinct from the (normal) code that throws the exception --- the try block. • Using an Exception: If your exception handler is not significantly different from Java’s, let Java handle it.

20. Effective Design (Cont’d) • Handling Exceptions. • Report the exception and terminate the program; • Fix the exceptional condition and resume normal execution. • Report the exception to a log and resume execution. • Program Development. Exceptions help identify design flaws during program development. • Report and Resume. Failsafe programs should report the exception and resume.

21. Effective Design (Cont’d) • Defensive Design. Anticipate potential problems, especially potential input problems. • Fixing an Exception. Handle fixable exceptions locally. This is both clearer and more efficient. • Library Exception Handling. Many library classes leave exception handling to the application. • Truly Exceptional Conditions. Use exceptions to handle truly exceptional conditions, not for expected conditions.

22. Summary of Important Points • In Java, when an error occurs, you throw an Exception which is caught by exception handlercode . A throw statement --- throw new Exception() --- is used to throw an exception. • A try block is contains one or more statements that may throw an exception. Embedding a statement in a try block indicates your awareness that it might throw an exception and your intention to handle the exception.

23. Summary of Important Points (Cont’d) • Checked exceptions must be caught or declared by the method in which they occur. • Unchecked exceptions (subclasses of RuntimeException) are handled by Java if they are not caught in the program. • A catch block contains statements that handle the exception that matches its parameter. • A catch block can only follow a try block. • There may be more than one catch block for each try block.

24. Summary of Important Points (Cont’d) • The try/catch syntax separates the normal parts of an algorithm from special exceptional handling code. • A method stack trace is a trace of a program’s method calls -- Exception.printStackTrace(). • Static scoping: how the program is written. Depends on declarations and definitions. • Dynamic scoping: how the program is executed. Depends on method calls.

25. Summary of Important Points (Cont’d) • Finding a Catch Block: Search upward through the static scope, and backward through the dynamic scope. • The Java Virtual Machine handles unchecked exceptions not caught by the program. • Many Java library methods throw exceptions when an error occurs. • Example: Java's integer division operator will throw anArithmeticException if an attempt is made to divide by zero.

26. Summary of Important Points (Cont’d) • Four ways to handle an exception: • Let Java handle it. • Fix the problem and resume the program. • Report the problem and resume the program. • Print an error message and terminate. • The (optional) finally block contains code that will be executed whether an exception is raised or not. • Exceptions should be used for exception truly exceptional conditions, not for normal program control. • User-defined exceptions can extend the Exception class or one of its subclasses.

27. A Complete Program • Program: • Asks user for name of file • File expected to contain data values • First line of file contains total number of values • Remaining lines contain the data • Typical input file: 3 1.45 -2.1 0.05

28. A Complete Program (Cont’d) • What can go wrong? • File might not exist • File might have data in wrong format • Who can detect the faults? • FileReader constructor will throw an exception when file does not exist • Methods that process input need to throw exception if they find error in data format Continued…

29. A Complete Program (Cont’d) • What exceptions can be thrown? • FileNotFoundException can be thrown by FileReader constructor • IOException can be thrown by close method of FileReader • BadDataException, a custom checked exception class Continued…

30. A Complete Program (Cont’d) • Who can remedy the faults that the exceptions report? • Only the main method of DataSetTester program interacts with user • Catches exceptions • Prints appropriate error messages • Gives user another chance to enter a correct file

31. File DataSetTester.java 01: import java.io.FileNotFoundException; 02:import java.io.IOException; 03:import java.util.Scanner; 04: 05:public class DataSetTester 06:{ 07:public static void main(String[] args) 08: { 09: Scanner in = new Scanner(System.in); 10: DataSetReader reader = new DataSetReader(); 11: 12:boolean done = false; 13:while (!done) 14: { 15:try 16: { Continued…

32. File DataSetTester.java 17: System.out.println("Please enter the file name: "); 18: String filename = in.next(); 19: 20:double[] data = reader.readFile(filename); 21:double sum = 0; 22:for (double d : data) sum = sum + d; 23: System.out.println("The sum is " + sum); 24: done = true; 25: } 26:catch (FileNotFoundException exception) 27: { 28: System.out.println("File not found."); 29: } 30:catch (BadDataException exception) 31: { 32: System.out.println ("Bad data: " + exception.getMessage()); Continued…

33. File DataSetTester.java 33: } 34:catch (IOException exception) 35: { 36: exception.printStackTrace(); 37: } 38: } 39: } 40:}

34. The readFile method of the DataSetReader class • Constructs Scanner object • Calls readData method • Completely unconcerned with any exceptions Continued…

35. The readFile method of the DataSetReader class • If there is a problem with input file, it simply passes the exception to caller public double[] readFile(String filename) throws IOException, BadDataException // FileNotFoundException is an IOException { FileReader reader = new FileReader(filename); try { Scanner in = new Scanner(reader); readData(in); } Continued…

36. The readFile method of the DataSetReader class finally { reader.close(); } return data; }

37. The readFile method of the DataSetReader class • Reads the number of values • Constructs an array • Calls readValue for each data value • Checks for two potential errors • File might not start with an integer • File might have additional data after reading all values • Makes no attempt to catch any exceptions private void readData(Scanner in) throws BadDataException { if (!in.hasNextInt()) throw new BadDataException("Length expected"); int numberOfValues = in.nextInt(); data = new double[numberOfValues]; for (int i = 0; i < numberOfValues; i++) readValue(in, i); if (in.hasNext()) throw new BadDataException("End of file expected"); }

38. The readFile method of the DataSetReader class • Checks for two potential errors • File might not start with an integer • File might have additional data after reading all values • Makes no attempt to catch any exceptions

39. The readFile method of the DataSetReader class private void readValue(Scanner in, int i) throws BadDataException { if (!in.hasNextDouble()) throw new BadDataException("Data value expected"); data[i] = in.nextDouble(); }

40. Scenario • DataSetTester.main calls DataSetReader.readFile • readFile calls readData • readData calls readValue • readValuedoesn't find expected value and throws BadDataException • readValue has no handler for exception and terminates Continued…

41. Scenario • readDatahas no handler for exception and terminates • readFile has no handler for exception and terminates after executing finally clause • DataSetTester.main has handler for BadDataException; handler prints a message, and user is given another chance to enter file name

42. File DataSetReader.java 01:import java.io.FileReader; 02:import java.io.IOException; 03:import java.util.Scanner; 04: 05: /** 06: Reads a data set from a file. The file must have // the format 07: numberOfValues 08: value1 09: value2 10: . . . 11: */ 12:public class DataSetReader 13:{ Continued…

43. File DataSetReader.java 14: /** 15: Reads a data set. 16: @param filename the name of the file holding the data 17: @return the data in the file 18: */ 19:public double[] readFile(String filename) 20:throws IOException, BadDataException 21: { 22: FileReader reader = new FileReader(filename); 23:try 24: { 25: Scanner in = new Scanner(reader); 26: readData(in); 27: } 28:finally 29: { 30: reader.close(); 31: } Continued…

44. File DataSetReader.java 32:return data; 33: } 34: 35: /** 36: Reads all data. 37: @param in the scanner that scans the data 38: */ 39:private void readData(Scanner in) throws BadDataException 40: { 41:if (!in.hasNextInt()) 42:thrownew BadDataException("Length expected"); 43:int numberOfValues = in.nextInt(); 44: data = newdouble[numberOfValues]; 45: 46:for (int i = 0; i < numberOfValues; i++) 47: readValue(in, i); Continued…

45. File DataSetReader.java 48: 49:if (in.hasNext()) 50:throw new BadDataException("End of file expected"); 51: } 52: 53: /** 54: Reads one data value. 55: @param in the scanner that scans the data 56: @param i the position of the value to read 57: */ 58:private void readValue(Scanner in, int i) throws BadDataException 59: { Continued…

46. File DataSetReader.java 60:if (!in.hasNextDouble()) 61:throw new BadDataException("Data value expected"); 62: data[i] = in.nextDouble(); 63: } 64: 65:private double[] data; 66:}