CS203 Java Object Oriented Programming Errors and Exception Handling

Examples of Exceptions ArrayIndexOutOfBoundException NumberFormatException int a[] = new int[10]; for( int i=0 ; i <= a.length ; ++i ) a[i] = i; String s = “7.3”; int n = Integer.parseInt( s );

Runtime Errors Errors happened when the program is running, e.g. Access an element outside array boundary Read a file which doesn’t exist User input errors Runtime error handling Error codes Exceptions

Exception Types

System Errors System errors are thrown by JVM and represented in the Error class. The Error class describes internal system errors. Such errors rarely occur. If one does, there is little you can do beyond notifying the user and trying to terminate the program gracefully.

Exceptions Exception describes errors caused by your program and external circumstances. These errors can be caught and handled by your program.

Runtime Exceptions RuntimeException is caused by programming errors, such as bad casting, accessing an out- of-bounds array, and numeric errors.

Checked Exceptions vs. Unchecked Exceptions RuntimeException, Error and their subclasses are known as unchecked exceptions. All other exceptions are known as checked exceptions, meaning that the compiler forces the programmer to check and deal with the exceptions.

Unchecked Exceptions In most cases, unchecked exceptions reflect programming logic errors that are not recoverable. For example, a NullPointerException is thrown if you access an object through a reference variable before an object is assigned to it; an IndexOutOfBoundsException is thrown if you access an element in an array outside the bounds of the array. These are the logic errors that should be corrected in the program. Unchecked exceptions can occur anywhere in the program. To avoid cumbersome overuse of try-catch blocks, Java does not mandate you to write code to catch unchecked exceptions.

Checked or Unchecked Exceptions Unchecked exception.

Error Codes // n >= 1 int factorial( int n ) { // return an error code if( n < 1 ) return –1; int fact = 1; for( int i=1 ; i <= n ; ++i ) fact *= i; return fact; } int f = factorial(x); if( f == -1 ) // error handling { System.err.println( “error!”); System.exit(1); } else // regular code { // do something with f }

Raise An Exception – throw int factorial( int n ) throws LessThanOneException { if( n < 1 ) throw new LessThanOneException(); int fact = 1; for( int i=1 ; i <= n ; ++i ) fact *= i; return fact; }

A Closer Look at Throw int factorial( int n ) throws LessThanOneException { if( n < 1 ) throw new LessThanOneException(); int fact = 1; for( int i=1 ; i <= n ; ++i ) fact *= i; return fact; } Return type Returned value Exception type Exception value

Exception Class Pre-defined in Java All exception classes must inherit from this class Important methods Exception() Exception( String msg ) String getMessage() void printStackTrace()

Create An Exception Class public class LessThanOneException extends Exception { public LessThanOneException() { super(); } public LessThanOneException( String msg ) { super(msg); }

Handle An Exception – try and catch try// regular code { int f = factorial(n); // do something with f } catch( LessThanOneException e ) // error handling { System.err.println( “error!” ); System.exit(1); }

Using Exceptions In a method where an error may occur Declare exception type in method header: throws Raise an exception if the error occurs: throw In the calling method Handle the exception  Enclose regular code in a try block  Enclose error handling code in a catch block Do not handle the exception  Declare the exception in method header

Throw Multiple Exceptions public void foo() throws ExceptionA, ExceptionB, ExceptionC { … throw new ExceptionA(“Bad thing A”); … throw new ExceptionB(“Bad Thing B”); … throw new ExceptionC(“Bad Thing C”); }

Catch Multiple Exceptions Or, if we don’t need to distinguish exactly which type of exception occurs try { foo(); } catch( ExceptionA ea ) { // do something } catch( ExceptionB eb ) { // do something } catch( ExceptionC ec ) { // do something } try { foo(); } catch( Exception e ) { System.err.println( e.getMessage() ); System.exit(1); }

A More Complex Example readFile { open the file; determine its size; allocate that much memory; read the file into memory; close the file; }

Handling Errors with Error Code errorCodeType readFile { 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; } close the file; if (theFileDidntClose && errorCode == 0) { errorCode = -4; } else { errorCode = errorCode and -4; } } else { errorCode = -5; } return errorCode; }

Handling Errors with 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; } }

Advantages of Exceptions Separate error handling code with from regular code Propagate errors up the call stack Group error types and error differentiation

Error Propagation Example method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 throws exception { call method3; } method3 throws exception { call readFile; }

Error Grouping and Differentiation Example

The finally Clause try { statements; } catch(TheException ex) { handling ex; } finally { finalStatements; }

Cautions When Using Exceptions Exception handling separates error- handling code from normal programming tasks, thus making programs easier to read and to modify. Be aware, however, that exception handling usually requires more time and resources because it requires instantiating a new exception object, rolling back the call stack, and propagating the errors to the calling methods.

When to Throw Exceptions An exception occurs in a method. If you want the exception to be processed by its caller, you should create an exception object and throw it. If you can handle the exception in the method where it occurs, there is no need to throw it.

When to Use Exceptions When should you use the try-catch block in the code? You should use it to deal with unexpected error conditions. Do not use it to deal with simple, expected situations. For example, the following code try { System.out.println(refVar.toString()); } catch (NullPointerException ex) { System.out.println("refVar is null"); }

When to Use Exceptions is better to be replaced by if (refVar != null) System.out.println(refVar.toString()); else System.out.println("refVar is null");

Creating Custom Exception Classes F Use the exception classes in the API whenever possible. F Create custom exception classes if the predefined classes are not sufficient. F Declare custom exception classes by extending Exception or a subclass of Exception.