Programming in Java

1. http://www.csie.nctu.edu.tw/~tsaiwn/java/ Programming in Java Exception Handling again 蔡文能 交通大學資訊工程學系 tsaiwn@csie.nctu.edu.tw

2. Agenda • Exception handling • Exception handling in Java • Exception handling in C++

3. Exception? • An exception is any unusual event, either erroneous or not, detectable by either hardware or software, that may require special processing • Without exception handling • When an exception occurs, control goes to the operating system, where typically • an error message is displayed • the program is terminated • With exception handling • Programs are allowed to trap exceptions • There is a possibility to fix the problem and continuing execution

4. What to do when Exception occurs? • There are several ways a function may react when encountering an unexpected/erroneous situation (i.e., Exception ) • Terminate the program • Cannot be used in a program that cannot afford to crash • Return a value representing “error” • Raise a flag • Many standard C library functions used global variable errno • Need to check the flag after every operation • Losses information • Call a function supplied to be called in case of error • Raise a signal / Event • How will it handle the error? char* String::getString(); //ok: return NUKK on error int atoi(constchar *); //what to return for “bad-str”?

5. When To Use Exceptions • Required by compiler when using some statements (Java) • Make code safer (catch fatal errors)‏ • Fix the problem and try again • Patch the problem and continue • Make a complex error mechanism simpler

6. Exception example try { readFromFile("datafile"); } catch (FileNotFoundException e) { System.err.println("Error: File not found"); }

7. Exception Handling: Some Options • Print something • Throw a new exception • Re-Throw the exception • Fix the problem • Exit

8. Exception Handling: Printing • You can print a stack trace by calling the exception method printStackTrace() • Sometimes it's better to send error messages to stderr: • System.err.println("Error: invalid thingy"); • Some applications log error messages • file • logging service (syslog).

9. Throwing Objects • Why throw an object? • Additional data encapsulated • An object is created upon invoking the throw statement • Can be created with additional data, passed to Ctor • Object is destroyed after the catch clause ends

10. Exception Handling: throw • You can throw an exception (object) from an exception handler (a catch block). • Allows you to change exception type and/or error message. • You can also alter the base of the stack trace • fillInStackTrace()

11. Exception Handling: Re-throw • You can throw an exception from an exception handler (a catch block) without changing anything: • called rethrowing • The caller needs to deal with the exception. • This also happens if you don't catch the exception! • sometimes you need to take some action and then rethrow the exception.

12. Another way to re-throw • You can allow selected types of exceptions to be propogated to the caller of your method: void blah() throws IOException { • Within blah() you don't need to catch these exceptions (to be able to compile).

13. Exception example public class ThrowUp { public static void main(String[ ] args) { String tmp; try { // generate an ArrayIndexOutOfBoundsExceptions .. // .. (on purpose!). for (int i=0 ; i<args.length+10 ; i++) { tmp = args[i]; } System.out.println("I made it!"); } catch (ArrayIndexOutOfBoundsException up) { throw new SecurityException("Trouble"); } } // main }

14. Exception Handling: Fix the problem. • You can't fix things and then resume execution automatically • you can do this in C++. • You can have a loop the retries the code again.

15. Exception Handling: exiting • Sometimes the error is fatal, and you want to stop the program immediately. • System.exit();

16. Wait.java public class Wait { public static void main(String[ ] args) { boolean done=false; int seconds=0; try { seconds = Integer.parseInt(args[0]); } catch (Exception e) { System.out.println("Please specify the number of seconds"); System.exit(1); } long initialtime = System.currentTimeMillis( ); while (!done) { try { if (System.currentTimeMillis()-initialtime < seconds*1000) throw new Exception("Not Yet - keep trying"); done=true; } catch (Exception e) { System.out.println(e); } } System.out.println("Done!\n"); } }

17. How/when do you generate exceptions? • Use throw: throw new Exception("broken!"); • You can use throw anywhere. • you detect some error that means the following code should not be executed. • In some cases, you can think of throw as a alternate return

18. Exception Enforcement • In general, you do the following: • specify what exceptions each method can generate. • write code to catch all exceptions that can be generated by a method call. • The compiler (usually) enforces this • it is a compilation error to call a method without catching it's declared exception types.

19. RunTime Exceptions • There are exceptions that are generated by the system (that are usually caused by programming mistakes): • NullPointerException (null references) • ArrayIndexOutOfBoundsException • If you don't catch these, a stack trace will be generated and the program will terminate. • The compiler does not force you to catch these exceptions.

20. Exception Types • Exceptions are objects! • Exception types are classes. • A (quite large!) hierarchy of classes. • All exception types are derived from the class Exception • there are some methods defined in this base class.

21. NullPointer.java import java.util.*; public class NullPointer { public static void main(String[ ] args) { Date f = new Date(); f=null; PrintSomething2(f); // comment out to test PrintSomething PrintSomething(f); } // no checks, if x is null runtime exception default behavior static void PrintSomething(Object x) { System.out.println(x.getClass( ).getName()); } // we explicitly check for runtime exception! static void PrintSomething2(Object x) { try { System.out.println(x.getClass().getName()); } catch (RuntimeException re) { System.out.println("Fatal Error!"); System.exit(1); } } // main }

22. Exception Error Exception Type Hierarchy (partial) Throwable VirtualMachineError RunTimeException IOException NullPointerException EOFException ArithmeticException

23. Some Exception Methods • These are actually inherited from throwable printStackTrace() fillInStackTrack() getMessage()

24. Creating Your Own Exception Types • It is often useful to create your own type of exception. • generally all you create is a name. • you can get fancy and add new methods to your exception class(es).

25. User-defined Exception Type class FooException extends Exception {} // .. class BlahException extends Exception { BlahException(){} BlahException(String s) { super(s); } } // .. throw new BlahException("Invalid blah");

26. using finally try { statements . . . } catch (ExceptionType1 ename1) { error handling statements . . . } catch (ExceptionType2 ename2) { error handling statements . . . } finally { … this code always executed … }

27. Why finally? • What is there to clean up? • No memory cleanup required in Java! • No destructors to call! • Sometimes you need to set the state of things (fields) to some stable (acceptable) state.

28. Exception Handling again 謝謝捧場 http://www.csie.nctu.edu.tw/~tsaiwn/java/ 蔡文能