Exceptions. Gunnar Gotshalks EX 1

Transcription

1 Exceptions EX 1

2 Exceptions Are surprising events that occur during the execution of a program» Not surprising that exceptions may occur > so we can prepare for them in a general way» Surprising in that > we do not know when they will occur Examples» Natural disasters» People become ill» Machines break EX 2

3 Exceptions 2 An occurrence out of the normal or expected flow of events» precondition not being satisfied > We expect user to pass valid parameters > Done during development debugging > As a rule checking input parameters leads to software bloat and MADNESS» postcondition not being satisfied > this is the proper use of exceptions Algorithm failed Hardware, IO, software error occurred EX 3

4 Exception Handling Basis is a variation on choice to distinguish between normal situation and exceptional situation» if situation normal then proceed else notify authority exception occurred fi What is different from choice?» Only notify system that a problem has occurred» Do not handle the exception > Do not do the recovery operation > Let the proper authority do the recovery EX 4

5 Exception Handling 2 If the routine detecting the exception can handle it then it is not an exception» The designer can build in the correct thing to do in all situations It is only an exception if the routine detecting the exception cannot handle it» Cannot build in the appropriate response for all situations > E.G. stack overflow display a message and continue as if normal situation? Not good for autopilot software in an airplane EX 5

6 Notify Authority Authority is a higher up» The caller The caller knows the context» They are more likely to be able to handle the exception > Do the correct thing in the context of the exception» If they do not know what to do!not enough context pass the problem to the next higher authority EX 6

7 Notify Authority 2 In Java the throw statement is the equivalent of passing the problem up the chain of command public Stack( final Sequence container) { if (container.isempty()) { this.container = (Sequence) container.clone(); else { throw new NotEmptyException(); EX 7

8 Throw Statement throw new < exception constructor > ( [ parameter ] ); Two main variations > Parameter less throw new NotEmptyException (); > Single string parameter throw new NotEmptyException ("Container must be empty"); EX 8

9 Handling an exception If exceptions can occur, the authority must be prepared to handle them» Use the try block The exception is thrown by the routine noticing the problem, so the authority dealing with the exception catches the exception» Use the catch block EX 9

10 Handling an exception 2 Used when the caller of a routine is prepared to handle situations out of the ordinary. > First enclose the calls in a try block signalling willingness to handle exceptions try { mystack = new Stack( acontainer ); > Followed by the exception handler program text in a catch block catch ( NotEmptyException e ) { print_line("test 24 caught the exception"); EX 10

11 Try-Catch Statement try { Block of statements catch ( < Exception type 1 > < Identifier > ) {... Block of statements for this exception Identifier is an object describing the exception catch ( <Exception type N> <Identifier> ) { Block of statements for this exception Identifier is an object describing the exception finally { Executed EVERY time try is executed > finally is optional EX 11

12 Try-Catch Statement 2 Can catch many different exception types in the same try-catch statement Catch blocks are tried in sequence» First one that matches the exception type is executed» This is important for handling errors either for a single type or for a collection of similar types in one catch block > Becomes more meaningful after we discuss inheritance EX 12

13 Try-Catch Statement 3 The catch block can do anything it likes including passing an exception up to the next higher routine» The exception type is changed > Because the next level up has a different context!needs different information that this level can supply try { mystack = new Stack( acontainer ); catch ( NotEmptyException e ) { throw new TroubleInRiverCity("Pool table"); EX 13

14 Cannot Handle Exception? Pass the Buck If a routine is unable/unwilling to handle an exception it can automatically pass it up the chain of command» Do not have a try-catch block Throwing the exception > But Java expects us to at least state this situation public void dowork(...) throws NotEmptyException { mystack = new Stack( acontainer ); EX 14

15 Throwables We have the following picture in Java Throwable Exception Error RunTimeException Used only by the Java virtual machine DONOT EXTEND Only extend this class EX 15

16 NotEmptyException Class public class NotEmptyException extends RuntimeException { /** Exception without a message. */ public NotEmptyException () { super(); /** Exception with a message. */ public NotEmptyException ( final String s ) super(s); EX 16

17 TroubleInRiverCity Class public class TroubleInRiverCity extends RuntimeException { /** Exception without a message. */ public TroubleInRiverCity () { super(); /** Exception with a message. */ public TroubleInRiverCity ( final String s ) super(s); EX 17

18 On the Stack Example Consider the following use of exception require isempty(container) public Stack( final Sequence container) { if (container.isempty()) { this.container = (Sequence) container.clone(); else { throw new NotEmptyException(); It is checking the input parameter» From this perspective not a good use of exception > So why is this here? EX 18

19 On Stack Example 2 Consider the postcondition ensure the stack uses the input storage type > This is incomplete, the routine actually creates an empty container of the correct type > should have ensure the stack uses the input storage type and size = 0 Now if we clone a nonempty container the postcondition is not satisfied» As well there is no universal error handling we can do > A good use of exceptions EX 19

20 On Stack Example 3 BUT» we can do something reasonable, for all cases that achieves the post condition without an exception > Create an empty list of the correct type public Stack( final Sequence container) { this.container = (Sequence) container.clone(); container.removeall; EX 20

21 On Stack Example 4 The benefits» Less restrictions on the user of the Stack require True Instead of require empty container» No need for an exception Caveats» Need a warning to the user that passing non empty containers may be expensive EX 21