CSE 501N Fall ’09 17: Exception Handling 03 November 2009 Nick Leidenfrost

Lecture Outline Lab 6 Questions? Exceptions & Errors throws statement Exception Handling: try/catch blocks finally statement

Error Handling: Error Codes Traditional approach: Method returns error code public static final int NO_ERROR = 0; public static final int BAD_INPUT = -1; public static final int INVALID_STATE = -2; // ... public int doSomething (int someInput) { if (!isValidInput(someInput)) return BAD_INPUT; // ... Method body return 0; }

Error Handling: Error Codes Problem: Caller is not forced to check for error code (Failure notification may go undetected) Problem: Calling method may not be able to do anything about failure Caller must also fail and let its caller worry about it Many method calls would need to be checked Lots of special logic would be introduced for handling errors

Error Handling: Error Codes Instead of programming for success: You would always be programming for failure: int theAnswer = x.doSomething(0); IntStorage answer = new IntStorage(0); int errorCode = x.doSomething(0, answer); if (errorCode != x.NO_ERROR) return errorCode;

Error Handling Java provides two ways of dealing with abnormal circumstances: Exceptions “… conditions that a … program might want to catch” Derived from java.lang.Exception Errors “… serious problems that a … program should not try to catch” Derived from java.lang.Error

We throw an exception with the throw clause. Throwing Exceptions Exceptions: Alter control flow to code intended to deal with the problem: Exception handlers Can't be overlooked Java compiler checks for existence of exception handlers Throw an exception object to signal an exceptional condition (or abnormal condition) Example: IllegalArgumentException: Method execution is halted at this point and control flow is returned to the calling method. We throw an exception with the throw clause. // illegal parameter value Exception iaException = new IllegalArgumentException(“Key cannot be null."); throw iaException;

Throwing Exceptions No need to store exception object in a variable: When an exception is thrown, method terminates immediately Execution continues with an exception handler which handles the type of exception that was thrown throw new IllegalArgumentException(“Key cannot be null.“);

Example public class HashMap { public void put (Object key, Object value) { if (key == null) { IllegalArgumentException exception = new IllegalArgumentException(“Key cannot be null.“); throw exception; } // ... } }

Types of Exceptions Two types of exceptions: Checked Unchecked The compiler will check to make sure code exists to handle the exception Unchecked Usually arise in circumstances that would be impossible for the compiler to predict A.k.a. Runtime exceptions [ Eclipse Example ]

Hierarchy of Exception Classes The Hierarchy of Exception Classes

Checked vs. Unchecked Exceptions Usually due to external circumstances that the programmer cannot prevent The compiler checks that you don't ignore them outright You must define exception handlers Mainly occur when dealing with input and output For example, IOException caused by File manipulation, Networking, user input, etc.

Checked vs. Unchecked Exceptions Unchecked Exceptions / Errors: Extend the class RuntimeException or Error They are (usually) the programmer's fault Examples of runtime exceptions: Example of error: OutOfMemoryError NullPointerException ArrayIndexOutOfBoundsException IllegalArgumentException

Checked vs. Unchecked Exceptions Categories aren't perfect: Scanner.nextInt throws unchecked InputMismatchException Programmer cannot prevent users from entering incorrect input This choice makes the class easy to use for beginning programmers Deal with checked exceptions principally when programming with files and streams Coming up in a few lectures… [ Eclipse Scanner Example ]

The throws clause If an exception can be thrown, the compiler will make sure our code acknowledges the exception Two choices: Handle the exception in this method We’ll look at how to do this in a bit… Tell compiler that you want method to be terminated when the exception occurs Use throws keyword to tell Java an exception may be thrown inside the method body that is not handled public void read(String filename) throws FileNotFoundException { FileReader reader = new FileReader(filename); Scanner in = new Scanner(reader); . . . }

The throws clause For multiple exceptions: Keep in mind inheritance hierarchy: If method can throw an IOException and FileNotFoundException, only use IOException Better to declare exception than to handle it incompetently public void read(String filename) throws IOException, ClassNotFoundException

Syntax: Exception Specification accessSpecifier returnType methodName(parameterType parameterName, . . .) throws ExceptionClass, ExceptionClass, . . . Example:  public void read(BufferedReader in) throws IOException Purpose: To indicate the checked exceptions that this method can throw

Exception Handlers Catching Exceptions Write exception handlers with the try/catch statement try block contains statements that may cause an exception catch clause contains handler for an exception type

Catching Exceptions: Syntax try { // Code that might cause Exceptions } catch (Exception exception) { // Code to handle Exceptions

Catching Exceptions: control flow Statements in try block are executed If no exceptions occur, catch clauses are skipped If exception of matching type occurs, execution jumps to catch clause If exception of another type occurs, it is thrown until it is caught by another try/catch block

Catching Exceptions: the catch clause catch (IOException exception) { } exception contains reference to the exception object that was thrown catch clause can analyze object to find out more details exception.printStackTrace(): printout of chain of method calls that lead to exception

Catching Errors: the catch clause It is possible to catch Errors, also. Because Errors are typically indicative of more serious problems, doing this is rare. Most often, the program is allowed to terminate. try { ... } catch (Error error) {

Syntax: Multiple catch clauses try { // statement // . . . } catch (ExceptionClass exceptionObject) {

Catching Multiple Types of Exceptions Throws java.lang.IOException try { String filename = “. . .”; FileReader reader = new FileReader(filename); Scanner in = new Scanner(reader); String input = in.next(); int value = Integer.parseInt(input); . . . } Throws java.lang.NumberFormatException catch (Exception exception) { exception.printStackTrace(); } catch (IOException exception) { exception.printStackTrace(); } catch (NumberFormatException exception) { System.out.println("Input was not a number"); }

The finally clause An uncaught exception terminates the current method - ! - This can skip over essential code Example: public void readSomeData () throws IOException { FileReader reader = new FileReader(filename); Scanner input = new Scanner(reader); readData(input); // Can throw an exception reader.close(); // May never get here }

The finally clause We want to execute reader.close() even if an exception happens Use finally clause for code that must be executed "no matter what"

Example: The finally clause FileReader reader = new FileReader(filename); try { Scanner in = new Scanner(reader); readData(in); } catch (IOException ioe) { // ... } finally { reader.close(); // finally clause is executed regardless // of whether exception occurs }

Syntax: The finally clause try { // statements } finally { // Notice that a try block can have a finally clause without a catch // Why is this?

The finally clause 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 For any of these ways, the finally block executes.

Designing Your Own Exception Types You can design your own exception types–subclasses of Exception or RuntimeException Checked Exceptions Unchecked Exceptions if (amount > balance) { throw new InsufficientFundsException( "withdrawal of " + amount + " exceeds balance of “ + balance); }

Designing Your Own Exception Types Make it an unchecked exception–programmer could have avoided it by calling getBalance first Extend RuntimeException or one of its subclasses (InvalidParameterException) Supply two constructors Default constructor A constructor that accepts a message string describing reason for exception

Designing Your Own Exception Types public class InsufficientFundsException extends RuntimeException { public InsufficientFundsException() {} public InsufficientFundsException (String message, double shortage) { super(message); } } public class InsufficientFundsException extends RuntimeException { public InsufficientFundsException() {} public InsufficientFundsException (String message) { super(message); } } Your type can include additional information needed to handle properly

Conclusion Questions? Lab 6 Due Tonight at Midnight Lab 7 Assigned Today Due 11/10 at Midnight Lab Now