1 / 46

Exception Handling

Exception Handling. 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.

mendezl
Télécharger la présentation

Exception Handling

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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:}

More Related