Exceptions and Design

Transcription

1 Exceptions and Exceptions and

2 Table of contents 1 Error Handling Overview Exceptions RuntimeExceptions 2 Exceptions and

3 Overview Exceptions RuntimeExceptions Exceptions Exceptions and

4 Overview Exceptions RuntimeExceptions Stack limitation Why did we implement a Positive Integer stack? Exceptions and

5 Overview Exceptions RuntimeExceptions Stack limitation Why did we implement a Positive Integer stack? We had to use the value -1 for error handling Exceptions and

6 Overview Exceptions RuntimeExceptions Stack limitation Why did we implement a Positive Integer stack? We had to use the value -1 for error handling Shouldn t there be a better way to do error handling? Exceptions and

7 Overview Exceptions RuntimeExceptions What is an Exception? A better way to announce some error happened Better than using special return values (i.e. return -1;) Gives the ability to respond to errors only where it s appropriate Separate normal code execution from error handling Exceptions and

8 Overview Exceptions RuntimeExceptions Announcing that an error happened The correct terminology is throwing an Exception An Exception is an Object containing information about what happened (and where) return -1; VS throw new Exception (" Something happened "); Exceptions and

9 Overview Exceptions RuntimeExceptions Exception method signature Part of the method signature (just like the return type) 1 2 int factorial ( int n) throws Exception { 3 if (n < 0) { 4 throw new Exception (" Negative number is not allowed "); 5 } else if (n == 0) { 6 return 1; 7 } else { 8 return n * factorial (n - 1); 9 } 10 } (Show compilation error when we forget the declaration) Exceptions and

10 Overview Exceptions RuntimeExceptions Exception method signature Same way as a return type is part of the method signature If you don t handle it, you must declare you may throw an Exception 1 2 int factorial ( int n) throws Exception { 3 if (n < 0) { 4 throw new Exception (" Negative number is not allowed "); 5 } else if (n == 0) { 6 return 1; 7 } else { 8 return n * factorial (n - 1); 9 } 10 } void printfactorial ( int n) throws Exception { 13 int result = factorial (n); 14 System.out. println ( result ); 15 } Exceptions and

11 Overview Exceptions RuntimeExceptions Responding to errors The correct terminology is catching an Exception Achieved by using a try/catch block 1 2 int factorial ( int n) throws Exception { 3 if (n < 0) { 4 throw new Exception (" Negative number is not allowed "); 5 } else if (n == 0) { 6 return 1; 7 } else { 8 return n * factorial (n - 1); 9 } 10 } void printfactorial ( int n) { 13 try { 14 int result = factorial (n); 15 System.out. println ( result ); 16 } catch ( Exception e) { 17 System.out. println (" Error "); 18 } 19 } Exceptions and

12 Overview Exceptions RuntimeExceptions Responding to errors void printfactorial ( int n) { 3 try { 4 int result = factorial (n); 5 System.out. println ( result ); 6 } catch ( Exception e) { 7 System.out. println (" Error "); 8 } 9 } Note When an exception will be thrown from factorial, no other lines of code inside the try block will be executed, the program jumps straight to the catch block Exceptions and

13 Overview Exceptions RuntimeExceptions Stack using Exceptions Lets improve the Stack we made last time We can remove the Positive from BoundedPositiveIntegerStack Exceptions and

14 Overview Exceptions RuntimeExceptions Stack using Exceptions - push New implementation of stack push 36 /** 37 * push an element into the stack. 38 * 39 element the element to push into the stack. 40 Exception if no space is left in stack. 41 */ 42 public void push ( int element ) throws Exception { 43 // check if we have space to add a new element 44 if ( numberofelements == this. elements. length ) { 45 throw new Exception ("No space left in stack "); 46 } // add the new element 49 this. elements [this. numberofelements ] = element ; 50 this. numberofelements += 1; } Exceptions and

15 Overview Exceptions RuntimeExceptions Stack using Exceptions - top New implementation of top 70 /** 71 * The top element in the stack. 72 * 73 the element on top of stack. 74 Exception if stack is empty. 75 */ 76 public int top () throws Exception { 77 // check if we have any elements in the stack 78 if (this. numberofelements == 0) { 79 // return an indication that the stack is empty 80 throw new Exception (" Stack is empty "); 81 } // return the correct element 84 return this. elements [this. numberofelements - 1]; 85 } Exceptions and

16 Overview Exceptions RuntimeExceptions Stack using Exceptions - pop New implementation of pop 54 /** 55 * Pop element from the stack. 56 * 57 the element on top of stack. 58 Exception if stack is empty. 59 */ 60 public int pop () throws Exception { 61 // get the element on top of the stack 62 int top = top (); 63 // decrement the number of elements, unless the stack is already empty 64 this. numberofelements -= 1; // return the element 67 return top ; 68 } Note If top() throws Exception, numberofelements value will not be affected, the code after top() will not be executed and we will immediately exit the method Exceptions and

17 Overview Exceptions RuntimeExceptions Stack using Exceptions Let s look at the complete code - exceptions.boundedintegerstack.java Let s look at the how it can be used - exceptions.stackusageexample.java Exceptions and

18 Overview Exceptions RuntimeExceptions Stack using Exceptions Note Let s look at the complete code - exceptions.boundedintegerstack.java Let s look at the how it can be used - exceptions.stackusageexample.java Would we want to use such an implementation? So much unnecessary code! There must be a better way! Exceptions and

19 Overview Exceptions RuntimeExceptions Exception vs RuntimeException Exception Must be handled (try/catch) Must be declared on methods (throws) RuntimeException Don t have to be handled (will still crash our code) Don t have to be declared (but probably should) Exceptions and

20 Overview Exceptions RuntimeExceptions Stack using RuntimeExceptions Note Let s look at the complete code - runtimeexceptions.boundedintegerstack.java Let s look at the how it can be used - runtimeexceptions.stackusageexample.java No unnecessary code, if application crashes we will have the exact reason! Exceptions and

21 Overview Exceptions RuntimeExceptions Why not always use RuntimeExceptions? Some actions are unpredictable by definition (for example opening a file) We want to force the user of our class to handle the problems and not ignore them. Exceptions and

22 Overview Exceptions RuntimeExceptions Code crashes In Java no such thing as a code crash Everything causes a RuntimeException (Show Examples - ExceptionExamples.java) Exceptions and

23 Overview Exceptions RuntimeExceptions Bad practices Never use the try/catch as a control flow An empty catch clause is a bad idea, you re just ignoring the problem 1 try { 2 while ( true ){ 3 System.out. println ( stack.pop ()); 4 } 5 } catch ( RuntimeException e){ 6 // Do nothing, the stack is just empty 7 } Exceptions and

24 Overview Exceptions RuntimeExceptions Bad practices Never use the try/catch as a control flow An empty catch clause is a bad idea, you re just ignoring the problem 1 try { 2 while ( true ){ 3 System.out. println ( stack.pop ()); 4 } 5 } catch ( RuntimeException e){ 6 // Do nothing, the stack is just empty 7 } A better approach 1 while (! stack. isempty ()){ 2 System.out. println ( stack.pop ()); 3 } Exceptions and

25 Command Query Separation Exceptions and

26 Command Query Separation Separate the methods of a class into two categories: Exceptions and

27 Command Query Separation Separate the methods of a class into two categories: Query Ask a question about the state of an object Should not alter the state of the object Exceptions and

28 Command Query Separation Separate the methods of a class into two categories: Query Ask a question about the state of an object Should not alter the state of the object Command Change the state of the object in some way Should not return any value Exceptions and

29 Command Query Separation Separate the methods of a class into two categories: Query Ask a question about the state of an object Should not alter the state of the object Command Change the state of the object in some way Should not return any value Why? Better design Easier to test Exceptions and

30 Command Query Separation - Stack Stack Queries top() size() isempty() - derived query (uses a basic size query) Exceptions and

31 Command Query Separation - Stack Stack Queries top() size() isempty() - derived query (uses a basic size query) Stack Commands push() pop() - is it a command if it returns a value? Exceptions and

32 Command Query Separation - Stack Note Stack Queries top() size() isempty() - derived query (uses a basic size query) Stack Commands push() pop() - is it a command if it returns a value? Can we do something to improve the design? Exceptions and

33 Command Query Separation - Stack Stack Queries top() size() isempty() - derived query (uses a basic size query) Stack Commands push() remove() Derived methods pop() - uses top() query and a remove() command Exceptions and

34 Improved Stack implementation New method remove 95 public void remove () throws RuntimeException { 96 // check if we have any elements in the stack 97 if (this. numberofelements == 0) { 98 throw new RuntimeException (" Stack is empty "); 99 } // return the correct element 102 this. numberofelements -= 1; 103 } New implementation of pop 61 public int pop () throws RuntimeException { 62 // get the element on top of the stack 63 int top = top (); // remove the element on top of stack 66 remove (); // return the element 69 return top ; 70 } Exceptions and

35 Unit Tests We should have an automatic test for our Stack See querycommand.boundedintegerstacktest Exceptions and

36 Exceptions and

37 Unbounded Stack Lets make the use of our stack even simpler! Why limit ourselves to deciding the maximum size at the beginning? What can we do? Exceptions and

38 Unbounded Stack Lets make the use of our stack even simpler! Why limit ourselves to deciding the maximum size at the beginning? What can we do? Add a resizeto(int newsize) method? Exceptions and

39 Unbounded Stack Lets make the use of our stack even simpler! Why limit ourselves to deciding the maximum size at the beginning? What can we do? Add a resizeto(int newsize) method? Why not make it transparent for our user? Exceptions and

40 Unbounded Stack New strategy Start with a small default size 22 IntegerStack () { 23 this. elements = new int [ DEFAULT_NEW_STACK_SIZE ]; 24 // initialize number of elements to 0 ( empty stack ) 25 this. numberofelements = 0; 26 } Note We will completely remove the second Constructor IntegerStack(int maxsize) Exceptions and

41 Unbounded Stack - signatures 22 IntegerStack () { 33 public void push ( int element ) { 63 public int pop () throws RuntimeException { 80 public int top () throws RuntimeException { 96 public void remove () throws RuntimeException { 111 public int size () { Exceptions and

42 Unbounded Stack New strategy Every time we run out of space, lets increase the array by a factor of 2 33 public void push ( int element ) { // do we have enough space for a new element? 36 if ( numberofelements == this. elements. length ) { // allocate a bigger array to hold our elements ( twice the size ) 39 int newsize = this. elements. length * 2; 40 int [] tmp = new int [ newsize ]; // copy old values to our new array 43 for (int i = 0; i < this. elements. length ; i += 1) { 44 tmp [i] = this. elements [i]; 45 } // replace reference, old array will be garbage collected 48 this. elements = tmp ; 49 } // add the new element 52 this. elements [this. numberofelements ] = element ; 53 this. numberofelements += 1; } 56 Exceptions and

43 Separation of Concerns A design principle that says that each module should address a separate concern Improves code re-usability Better code maintainability Code that is easier to understand Exceptions and

44 Separation of Concerns - Unbounded Stack What are the concerns in our latest IntegerStack implementation? Exceptions and

45 Separation of Concerns - Unbounded Stack What are the concerns in our latest IntegerStack implementation? Stack functionality concern Exceptions and

46 Separation of Concerns - Unbounded Stack What are the concerns in our latest IntegerStack implementation? Stack functionality concern Array resizing concern Exceptions and

47 Separation of Concerns - Unbounded Stack 2 What should we do? Exceptions and

48 Separation of Concerns - Unbounded Stack 2 What should we do? Create a new class UnboundedArray get(int index) set(int index, in value) Exceptions and

49 Separation of Concerns - Unbounded Stack 2 What should we do? Create a new class UnboundedArray get(int index) set(int index, in value) Use the new UnboundedArray in our IntegerStack implementation We can now use our UnboundedArray in other places Exceptions and

50 Separation of Concerns - Unbounded Stack 2 What should we do? Create a new class UnboundedArray get(int index) set(int index, in value) Use the new UnboundedArray in our IntegerStack implementation We can now use our UnboundedArray in other places Show Examples: separationofconcerns.unboundedintegerarray separationofconcerns.integerstack Exceptions and

51 Test changes - again We already have a Test, let s run it to see we didn t break anything! Exceptions and

52 Summary 1 Error Handling Overview Exceptions RuntimeExceptions 2 Exceptions and