Exception Handling

Transcription

1 Exception Handling

2 Exception Handling Types of exceptions Standard exceptions Propagating vs. handling exceptions HW#2 posted; due 9/23/2013 Reading assignment: EJ2, Chapter 9, Exceptions

3 Java allows every method an alternative exit path if it is unable to complete its task in the normal way. In this situation, the method does NOT return a value; instead it creates & throws an exception object that encapsulates the error information and it exits immediately Java s exception handling system will search the call stack for an exception handler that can deal with this error

4 An exception is an object it contains information about the problem methods exist which retrieves this information There are checked exceptions and unchecked exceptions There are 2 ways of dealing with exceptions: 1.throwing exceptions (propagation): the applications programmer decides what to do about the problem 2.handling exceptions (try/catch): the class designer handles it internally

5 public class Magic { public String castspell(int n) { // end Magic public class Lamp { public void init() { Magic m = new Magic(); String arg = m.castspell(42); // end Lamp public class Test { public static void main( ) { Lamp t = new Lamp(); 0. main() calls constructor t.init(); // end Test 3. Magic.castSpell() currently executing 2.0 calls constructor 2.1 Lamp.init() calls Magic.castSpell() 1. main() calls Lamp.init()

6 main() Lamp.init() Magic.castSpell() case 1: normal operation. 1. castspell() returns a string to the point of call case 2: exception occurs. currently executing 1. execution of castspell() immediately terminates, a string is not returned, do not return to point of call; 2. search backwards through call stack until an appropriate exception handler is found; if none found, program terminates

7 checked (meaning the compiler can check) most application exceptions are checked if you call a method which throws a checked exception, you MUST specify to the compiler how this will be handled: either (1) propagate (or throw) it, or (2) handle the error at once (try/catch) unchecked subclasses of java.lang.runtimeexception or java.lang.error (i.e. programming errors or system errors)

8 Standard Exceptions Object Throwable Exception Error AssertionError IOException RuntimeException FileNotFoundException ArithmeticException

9 Standard Exceptions Exception RuntimeException ArithmeticException ClassCastException NullPointerException

10 java.lang.exception Standard Exceptions java.io.ioexception EOFException MalformedURLException FileNotFoundException

11 /* Example: Want to write a method, readline(), that reads in a line of text. Algorithm: have a loop that calls System.in.read() which reads in one character. */ public int read() throws IOException Returns: the next byte of data, or -1 if the end of the stream is reached. Throws: IOException - if an I/O error occurs. This is a checked exception, so the method readline() must either handle the exception internally or propagate it externally

12 // Alternative 1: propagate the error // (let someone else in the call stack handle it) public static String readline() throws IOException { /* code to read in a line of text */ // Alternative 2: handle the error internally public static String readline() { try { /* code to read in a line of text */ catch(ioexception e) { /* do something sensible about an I/O error */

13 // Version 1: if error occurs, propagate the error // (loses partial line) public static String readline() throws IOException { int ch; String r = ""; boolean done = false; while(!done) { ch = System.in.read(); if ((ch < 0) (ch == '\n')) done = true; else return r; r = r + (char)ch; if an error occurs in read(), the code for read will create a new exception object and throw it here; then readline() will propagate (throw) the error to where it was called

14 // Test Version 1 of readline() import java.io.*; public class TestVersion1 { // Version 1: if error occurs, propagate the error public static String readline() throws IOException { public static void main(string[] args) { System.out.print("Enter a line:"); System.out.println(readLine()); compile error! why? unreported exception

15 // Test Version 1 of readline(), take 2 import java.io.*; public class TestVersion1 { // Version 1: if error occurs, propagate the error public static String readline() throws IOException { public static void main(string[] args) { System.out.print("Enter a line:"); try { System.out.println(readLine()); catch(ioexception e) { System.err.println(e.getMessage());

16 // Version 2: if read() fails, return partial line public static String readline() { int ch; String r = ""; boolean done = false; while(!done) { try { ch = System.in.read(); if (ch < 0) (char)ch == '\n') done = true; else r = r + (char)ch; catch(ioexception e) { done = true; return r;

17 // Test Version 2 of readline() import java.io.*; throws not here public class TestVersion2 { // Version 2: if error occurs, return partial line public static String readline() { try/catch must be here public static void main(string[] args) { System.out.print("Enter a line:"); System.out.println(readLine()); no compile error! why not?

18 Method propagates an error, i.e. throws an exception public static String readline() throws Exception { Calling code somewhere in the call stack must have a try/catch for that exception Method handles the error, so must contain a try/catch public static String readline() { try { catch (Exception exc1) { handle error Calling code doesn t have a try/catch

19 Should readline propagate the exception or handle it internally? Is there another alternative that is better?

20 try { // stuff catch (SomeException e1 ) { /* do something sensible about the error */ What to do? if caused by user error, give the user a chance to correct it take a sensible default action print (or display) an error message where? display pop-up dialog, etc.

21 All exceptions inherit the properties & methods of Throwable useful methods include: String getmessage(); // error message String tostring(); // short description void printstacktrace(); // backtrace void printstacktrace(printstream); tip: print to standard error stream System.err.println( system malfunction );

22 note: use System.err.println() NOT System.out.println() try { // stuff catch (SomeException e1 ) { System.err.println( e1.getmessage() ); System.err.println( e1.getclass().getname()); e1.printstacktrace( System.err );

23 Consider the BigInteger class in java.math: public class BigInteger /* arbitrary precision integers */ extends Number implements Comparable<BigInteger> /** Returns (this mod m) as a m, the modulus, which must be this mod m (0, 1,, m-1) */ public BigInteger mod(biginteger m) { /* compute and return (this modulo m) */

24 Example: BigInteger /* application programmer writes the following */ public static void main( ) { Random RNG = new Random(); BigInteger bi = new BigInteger(50, RNG); BigInteger ms = new BigInteger( 0 ); System.out.println( bi.mod(ms)); ERROR division by zero

25 /** Returns a BigInteger whose value is (this mod m the modulus, which must be this mod ArithmeticException if m <= 0 */ public BigInteger mod(biginteger m) throws ArithmeticException { if (m.signum() <= 0) throw new ArithmeticException( Modulus not positive ); // an exception object is created & the call stack is searched for code to handle the problem

26 /* application using BigInteger */ public static void main( ) { Random RNG = new Random(); BigInteger bi = new BigInteger(50, RNG); BigInteger ms = new BigInteger( 0 ); System.out.println( bi.mod(ms) ); PROBLEM where s the code to handle the error? Note that the compiler can determine that this is a problem. How? Because the header for BigInteger.mod() specifies that it throws an exception (specifically ArithmeticException)

27 public static void main( ) { Random RNG = new Random(); BigInteger bi = new BigInteger(50, RNG); BigInteger ms = new BigInteger( 0 ); try { System.out.println( bi.mod(ms) ); catch (ArithmeticException ex) { System.out.println(ex.getMessage()); Application programmer decides what to do: print an error message? let the user try again? whatever

28 for public methods, use tag to document the exception that will be thrown (typically IllegalArgumentException, IndexOutOfBoundsException, or NullPointerException) nonpublic methods should generally check their parameters using assertions (will cover at a later date)

29 IllegalArgumentException parameter value is inappropriate IllegalStateException object state is inappropriate NullPointerException parameter value is null where prohibited IndexOutOfBoundsException index parameter value is out of range

30 if an error is always the result of a programming error, make it a subclass of RuntimeException (unchecked) if an error is something the application can recover from: use checked exception class (extends Exception) the Error class is effectively reserved for the JVM, and is used to indicate resource deficiencies, invariant failures and other conditions that make it impossible to continue execution

31 String public String(byte[] bytes, int offset, int length) Constructs a new String by decoding the specified subarray of bytes using the platform's default charset. Parameters: bytes - the bytes to be decoded into characters offset - the index of the first byte to decode length - the number of bytes to decode Throws: IndexOutOfBoundsException - if the offset and the length arguments index characters outside the bounds of the bytes array

32 try { note that order is important // do stuff catch(ioexception ioe) { // handle this case catch(unknownhostexception uhe) { // handle this case catch(exception e) { // catch-all

33 If any of the code inside the try block throws an exception of the specified types, then 1. the program skips the remainder of the code in the try block 2. the program executes the handler code inside the matching catch clause If any of the code inside the try block throws a different kind of exception, the method exits immediately (presumably the calling code has a catch clause for that type) The exception objects, ioe, uhe, contains information about the error that occurred. Can use this when handling the problem.

34 Item 58: Use checked exceptions for recoverable conditions and run-time exceptions for programming errors checked caller can be reasonably be expected to recover from this type of error run-time indicates programming errors, such as precondition violations, array out of bounds, etc.

35 Exception types: suppose an error occurs main() Lamp.init() Magic.castSpell() public class Magic { public String castspell( int n) { char ch = System.in.read(); checked if (n < 0) throw new FooException( you idiot ); line[-1] = ch; thrown unchecked (array bounds error) system error

36 constructor for Circle throws exception public Circle(float radius, int x, int y) throws IllegalArgumentException; main program contains: { Circle c1 = new Circle(9f, 9, 9); Is there a problem?

37 constructor for Circle throws exception public Circle(float radius, int x, int y) throws IllegalArgumentException; main program contains: try { What s the problem? float z; int x, y; Should this exception even be caught? /* code to read values for z, x and y */ Circle c1 = new Circle(z, x, y); catch(illegalargumentexception iae) { System.err.println( illegal value ); System.out.println(c1.computeArea());

38 import javax.sound.midi.*; public class TheMusicMan { public void play() { error: unreported exception MidiUnavailableException; must be caught or declared to be thrown Sequencer sequencer = MidiSystem.getSequencer(); System.out.println("We have a sequencer\n"); public static void main(string[] args) { TheMusicMan mm = new TheMusicMan(); mm.play();

39 public static Sequencer getsequencer() throws MidiUnavailableException Returns: the default sequencer Throws: MidiUnavailableException - if the sequencer is not available due to resource restrictions, or there is no Receiver available by any installed MidiDevice, or no sequencer is installed in the system.