View
244
Download
0
Category
Preview:
Citation preview
CS203 Java Object Oriented ProgrammingErrors 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 ExceptionsIn 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 JavaAll exception classes must inherit from this classImportant 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 codePropagate errors up the call stackGroup 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 Clausetry { statements;}catch(TheException ex) { handling ex; }finally { finalStatements; }
Cautions When Using ExceptionsException 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 ExceptionsAn 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 ExceptionsWhen 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
Use the exception classes in the API whenever possible.
Create custom exception classes if the predefined classes are not sufficient.
Declare custom exception classes by extending Exception or a subclass of Exception.
Recommended