8. Exceptions. By the end of this session, you should be able to:

Transcription

1 8. Exceptions Objectives By the end of this session, you should be able to: write Java/C# code that can handle error conditions raised by the methods it calls write Java/C# methods that use exceptions to return errors create exception classes

2 Exceptions for You How do you handle errors? What if you have 20 similar types of errors that could occur, what do you do? What if all errors are widely different? What if you need to deal with it all the way in the display layer? End result of your code?

3 Traditional Error Handling Traditional error handling often relies on special error codes returned from a function in case of error Example: the Unix int read( ) system call: returns zero to mean end of file returns 1 and sets a global error code on input error

4 Traditional Error Handling (con t) Problems with error value return: varies from program to program, programmer to programmer return codes can be unusual or obscure context information is lost

5 Java/C# Exceptions Java/C# provides exceptions as a mechanism for error reporting and handling Exception reporting is: supported by the Java/C# language is application-general independent of normal method return value An exception is an object that describes a failure case: base class: java.lang.exception [Java] System.Exception [C#] some exception subclasses are defined by the Java/C# run-time ex. ArrayIndexOutOfBoundsException the programmer may also define exception classes

6 Java/C# Exceptions (con t) When an error is detected, the method that detects it can throw an exception: the calling code can define an exception handler to catch the exception and respond to the error. Otherwise it can pass on the error or it can throw the error again.

7 Java/C# Exceptions (Con t) method c() method b() method a() method main() call trace Exception thrown here. Caught here? If not or here? or here? or here? If an exception is not caught, it causes execution to terminate with an error message, it falls off!

8 Creating an Exception Class Example of creating an exception class: class MyException extends Exception { } class MyException: ApplicationException { } Exceptions can carry a detail message, which must be set in the constructor. This helps in the exception containing information about itself!!

9 Creating an Exception Class class MyException extends Exception { MyException(String message) { super(message) ; } } The message is exported through the getmessage() method: public String getmessage()

10 The throw Statement To throw an exception, use the statement: throw exception object; The object thrown is typically instantiated in the throw statement: if (a < 10) { throw new MyException ( value is less than 10 ); } The method that executes a throw is interrupted (as if it executed a return)

11 Defining an Exception Handler To handle an exception, the code that generates the exception must be enclosed within a try statement Following the try statement must be one or more catch statements, one for each type of exception being handled: try { dangerousmethod (); } catch (MyException e) { System.err.println(e.getMessage()); }

12 The catch Statement A catch statement has exactly one parameter, which must be of a class type A catch statement s parameter matches an exception type if: - the types are identical, or - the parameter type is a superclass of the exception type, or - the parameter type is an interface the exception type implements

13 The catch Statement (con t) When an exception is thrown within a try statement: the first catch statement with a matching parameter executes if no catch statement matches, the method terminates only the first matching catch statement is executed; other matching catch statements are skipped

14 The catch Statement (Con t) After the catch statement executes: the program continues after the try catch block unless the catch statement finishes by executing a return, throw, break or continue it is not possible to return to the point where the exception occurred

15 The catch Statement (Con t) try { a[i] = 100; dangerousmethod (); } catch (ArrayIndexOutOfBoundsException a){ //ignore } catch (MyException m) { return false; } catch (Exception e) { System.out.println ( What s this? +e); throw e; }

16 The finally Statement A finally statement can appear at the end of a try catch block A finally statement defines code that must be executed if any part of the preceding try block is executed If a local catch block catches an exception: the catch code runs first, then then finally block is executed

17 The finally Statement (con t) If an uncaught exception is thrown: the finally block is executed first, then the current method exits finally { } block is always executed, even after break, continue, return, or another throw. but, not after System.exit(0). This terminates the program before the finally statement

18 The finally Statement (Con t) Example of finally statements: //Suppose a method which locks an //object and this object must be // left locked for as short a // time as // possible obj.lock();

19 The finally Statement (Con t) try { dangerousmethod (); } catch (MyException m) { // the finally statement // executes // before this return! return false; } finally { obj.unlock (); }

20 Java Exception Types Exceptions generated by the Java run-time system are subclasses of java.lang.runtimeexception These include: - ArithmeticException - NullPointerException - ClassCastException - NegativeArraySizeException - ArrayIndexOutOfBoundsException - OutOfMemoryException

21 Java Exception Types (con t) Other predefined exception types: - ClassNoFoundException - NoSuchMethodException - InstantiationException - InterruptedException

22 The throws Clause in Java In Java if a method throws an exception: it must also catch the exception, or declare its intent to throw that type of exception in its declaration using the keyword throws: public int getval() throws Exception { }

23 The throws Clause in Java (con t) public int XX () throws Ex1, Ex2 { // place where Ex1 and Ex2 are // thrown } Likewise, if a method invokes another method that throws an exception, the invoking method must either: catch the exception, or cover that type of exception in its throws clause Subclasses of RuntimeException are excluded from this rule (called unchecked)

24 Constructors and Exceptions A constructor can also throw an exception The instantiation of the object whose constructor throws an exception must be within the try-catch block In Java over-loaded methods need not all conform to the throws clause

25 Summary Exceptions are objects that are thrown to signal an error Syntax for handling an exception uses: try { } catch (Exception excptn) { } finally { } To generate an exception with throw exception object; In Java a method must declare the types of exceptions it can throw using throws

26 Quiz 1. Find the compiler error in the following code. try { String str = have you found it yet? ; str.charat(-1); } catch (ArrayIndexOfBoundsError) {}

27 Quiz (con t) 2. What does the following code fragment print? char[] arr = new char [10]; try { arr[10] = A ; } catch (RuntimeException e) { System.out.println ( D E F ); throw e; } finally { System.out.println ( G H I ); }

28 Answers to Quiz 1. The parameter to the catch statement requires a name. 2. DEF GHI

29 Exercises 1. Write a test program that instantiates a String and initializes it to some non-null value. Attempt to access a character beyond the end of the string (you may use the charat() method). What happens when you run the program? 2. Modify your test program to catch the exception and print the exception s message (use the exception s getmessage() method).

30 Exercises (con t) 3. Revisit your Clock class. Modify the settime() method to throw an exception of type BadTime if any of the hour, minutes or seconds values are out of range. Now create the BadTime class. It should extend the Exception class and define two constructors, one with no arguments and one with a String argument that specifies the error message. Test your modified settime() method and your new exception class.