Exceptions in OO Programming Introduction Errors Exceptions in Java Handling exceptions The Try-Catch-Finally mechanism Example code Exception propagation Correct use of exception handling Benefits of exception handling Summary

Exceptions in OO Programming Errors The Golden Rule of Programming: Errors occur in software programs! How do we deal with errors? Try to minimise their occurrence (bug-checking). Prevent invalid data from entering the system (validation). Handling errors as they occur (exception handling). Exception handling is a coding mechanism which handles errors as they occur and prevents the program from crashing

Exceptions in OO Programming Exceptions Definition: An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. What kinds of exceptions can occur in Java? Input/Output exceptions Memory exceptions Mathematical exceptions Pointer exceptions, and many more... When an exception occurs it is said that the exception has been ‘thrown’.

Exceptions in OO Programming Checked and Unchecked Unchecked exceptions are the type of exceptions we don't want to have to catch. For example:nAverage = nSum/nTotalUsers; Can generate a divide-by-zero exception! We don't put try/catch round every bit of maths. Checked exceptions are the ones we do need to catch and process. For example we may need to give feedback to a user to remind them to put a CD into a drive or to add paper to a printer.

Exceptions in OO Programming Handling Exceptions The mechanism for handling exceptions during program execution is the Try-Catch-Finally block. The general format for using these statements is: try { // some Java code that can cause an exception } catch(exception thrown) { // code to handle the exception } finally { // tidy up code (optional) }

Exceptions in OO Programming The Try Block The first step in constructing an exception handler is to enclose the statements that might throw an exception within a try block. In general, a try block looks like this: try { Java statements } The segment of code labelled Java statements is composed of one or more legal Java statements that could throw an exception.

Exceptions in OO Programming The Catch Block The try statement defines the scope of the exceptions which might be thrown. You provide one or more catch blocks directly after the try block: [why multiple catch blocks?] try {... } catch (... ) {... } catch (... ) {... }

Exceptions in OO Programming The Finally Block The final step in setting up an exception handler is providing a mechanism for cleaning up the state of the method before (possibly) allowing control to be passed to a different part of the program. You do this by enclosing the cleanup code within a finally block. The finally block comes in useful when a piece of code must be executed regardless of whether the try block was successful or not. e.g. closing a File object.

Exceptions in OO Programming File Example try {BufferedReader br = new BufferedReader(newFileReader("MyFile.txt")); String line = br.readLine(); } catch(FileNotFoundException fnfe) {System.out.println("File MyFile.txt not found."); } catch(IOException ioe) {System.out.println("Unable to read from MyFile.txt"); } return line;

Exceptions in OO Programming File Example The constructor of FileReader throws a FileNotFoundException (a subclass of IOException) if the specified file is not found. Otherwise, if the file exists but for some reason the readLine() method can't read from it FileReader throws an IOException. (maybe the file has user access privileges or is currently locked by another user)

Exceptions in OO Programming Propagation of Exceptions You can decide to not deal with an exception within a particular method, Then you must declare that the method can throw exceptions. These exceptions are then passed up the chain of calling methods. e.g. if some part of your sub-system produces an exception but you want your user-interface classes to deal with it then you can. All intervening methods must have their signatures set to throw the exception(s).

Exceptions in OO Programming Method Signatures A try-catch block must then be placed around the call to the top-level intervening method. If you are going to propagate an exception from a method then the method signature has to specify this. public String readHeader() throws FileNotFoundException, IOException {// method code }

Exceptions in OO Programming Example method1 {try { call method2; } catch (exception) { doErrorProcessing; } } method2 throws exception { call method3; } method3 throws exception { call readFile; }

Exceptions in OO Programming Correct Use Often, developers add the mechanism as an afterthought. Significant re-engineering during the coding stage can make this oversight an expensive proposition. A clear and detailed exception-handling strategy pays off in the form of robust code, which in turn, enhances user value.

Exceptions in OO Programming Benefits Java's exception-handling mechanism offers the following benefits: It separates the working/functional code from the error-handling code by way of try-catch clauses. It allows a clean path for error propagation. If the called method encounters a situation it can't manage, it can throw an exception and let the calling method deal with it.

Exceptions in OO Programming Benefits Java's exception-handling mechanism offers the following benefits: By enlisting the compiler to ensure that "exceptional" situations are anticipated and accounted for, it enforces powerful coding. Forcing the developer to code for exceptions improves the quality of information for users of the code – compare with C++ where exceptions are “unchecked” and often undocumented.

Exceptions in OO Programming Problems with Exceptions It can be hard to propagate exceptions at the appropriate level of abstraction, for example; A “SQLException” at one level could be a “DuplicateUserIDException” elsewhere. Sometimes handling exceptions properly is a lot of work for extremely rare cases. Lazy developers can easily avoid handling exceptions properly – and often do.

Exceptions in OO Programming Summary Errors can always occur. By using the exception handling mechanism, you can let your code deal with the error and continue execution. The exception handling mechanism separates your code from the code which deals with the error. This can be code that is placed further up the method call stack. Use of the exception handling mechanism leads to robust applications that users can feel confident with.