1. Summer 2007CISC121 - Prof. McLeod1 CISC121 – Lecture 6 Last time: –Encapsulation –Javadoc documentation –Testing and Debugging

2. Summer 2007CISC121 - Prof. McLeod2 You Should Be: Able to apply feedback from Assn 1 to Assn 2. Just about finished Assn 2. Finished reading over testing and debugging notes from last lecture.

3. Summer 2007CISC121 - Prof. McLeod3 You Will Need To: Look at Exercise 3 and start work on Assn 3 – both on Encapsulation. Prepare for midterm: –Krista will hold midterm prep tutorial at 4:30pm in GOO456 (the lab) on Monday. E-mail her if you intend to go! –Next Tuesday, the 24 th, at 10am – Note late start! –In BIO1120 (same room as lecture). –Look over and print out a copy of the aid sheet (now posted), if you want to use it.

4. Summer 2007CISC121 - Prof. McLeod4 Midterm Topics Fundamental Java, Including: –Expressions, Loops and Conditionals –Methods –File and Console I/O –Catching Exceptions Encapsulation Testing and Debugging (comprehension only) Linked Lists –(Staring, but not finishing, this topic today. I will not ask you anything hard on linked lists on the midterm.)

5. Summer 2007CISC121 - Prof. McLeod5 Midterm Format All hand-written on paper: Short answer comprehension questions. “What is the Output” questions. Write or complete or correct a method or program.

6. Summer 2007CISC121 - Prof. McLeod6 Today Finish up Testing and Debugging by looking at invariants. Start Linked Lists But first, let’s go over how the debugger works in Eclipse.

7. Summer 2007CISC121 - Prof. McLeod7 Debugging in Eclipse If you have not used Debug before – the “Debug Perspective” button will not show up at the top right. To use debug mode, you must put a breakpoint into your program, by right-clicking on the bar at the left of your program, and choosing “Toggle Breakpoint”. Then choose “Debug As” followed by “Java Application”.

8. Summer 2007CISC121 - Prof. McLeod8 Debugging in Eclipse, Cont. Now you are in the “Debug Perspective”! Lots of fun things to do here! –You can examine the current contents of variables and objects. –You can continue your program one line of code at a time. –etc.! (Also look at version history in Eclipse…)

9. Summer 2007CISC121 - Prof. McLeod9 Another logic tool that you can use to prove that your program is “correct” is the use of assertions. Special assertions are called: –Preconditions, –Postconditions & –Invariants. Essentially, an assertion is just a statement that describes a condition that should be true at a given point in your program. –An assertion could just be a comment. –Java provides the use of the “ assert ” command, that can do something useful in the event that the condition turns out to be false. Program Correctness

10. Summer 2007CISC121 - Prof. McLeod10 Pre- & Post- Conditions These assertions are made at the beginning of a method (pre-condition) and at the end of the method (post- condition). A precondition: –Specifies what is true before the method executes. –Describes the assumptions under which the method runs. –Satisfying the preconditions is the responsibility of the calling method (or “user”). A postcondition: –Specifies what is true after the method executes. –Describes the effects of the code. –Satisfying the postconditions is the responsibility of the person coding the method.

11. Summer 2007CISC121 - Prof. McLeod11 Pre- & Post- Conditions - Cont. These conditions form part of the specifications of the method. A piece of code is said to be correct if the postconditions will be satisfied for all possible states of the preconditions. It is not always possible to completely prove correctness by this definition. –Sometimes all you can say is that the postconditions will be satisfied whenever the method terminates normally. –This is called partial correctness.

12. Summer 2007CISC121 - Prof. McLeod12 Pre- & Post- Conditions - Cont. For example, a little method to see if a number is prime: public static boolean isPrime (int n) { for (int i = 2; i * i <= n; i++) if (n % i == 0) return false; return true; } // end is Prime method

13. Summer 2007CISC121 - Prof. McLeod13 Pre- & Post- Conditions - Cont. Add pre- and post- conditions: // pre: n is >= 2 public static boolean isPrime (int n) { for (int i = 2; i * i <= n; i++) if (n % i == 0) return false; return true; } // end is Prime method // post: true if n is prime, false // otherwise

14. Summer 2007CISC121 - Prof. McLeod14 Invariants Invariants are assertions that are placed at strategic positions within the code. Invariants state what is true at this position. If the program logic is correct, then one insertion should lead from the one before and the last insertion should prove the post-condition to be true. Next slide has our little method with invariants put in as comments:

15. Summer 2007CISC121 - Prof. McLeod15 // pre: n is >= 2 public static boolean isPrime (int n) { for (int i = 2; i * i <= n; i++) { // inv1: n has no factors between 2 and i-1 if (n % i == 0) { // inv2: i divides n evenly, therefore // n is not prime return false; } // inv3: n has no factors between 2 and i } // end for loop // inv4: n has no factors between 2 and // n, therefore n is prime return true; } // end is Prime method // post: true if n is prime, false otherwise

16. Summer 2007CISC121 - Prof. McLeod16 Invariants - Cont. Note how the invariants below depend on the invariants above. The invariant above must be true in order to allow the invariant below to be true. Also, the invariants above the return statements, inv3 & inv4, when combined, prove the post- condition to be true. So, if you can chain together the invariants between the pre- and post- conditions, and thus prove that the post condition is true, then you have proved the “correctness” of your program.

17. Summer 2007CISC121 - Prof. McLeod17 Invariants - Cont. In essence, the process is all about forming a contract between the pre- and post- conditions. Having proved the “correctness” of your program, you are now ready to subject your program to a thorough testing with real values. Since you can not test every possible input value, your proof of correctness along with some testing must be sufficient to give you confidence that your method works.

18. Summer 2007CISC121 - Prof. McLeod18 Aside – Loop Invariants “ inv1 ” is called a “loop invariant”, because it is inside the loop. For this kind of invariant: –Make sure it is true when the loop starts. –Make sure it stays true each time through the loop. –Does the invariant lead to the desired condition when the loop terminates? –Make sure the loop will terminate!

19. Summer 2007CISC121 - Prof. McLeod19 Program Correctness - Cont. For the example above, you could have walked through the logic in your head to prove that it works. Was all this fancy stuff necessary? The use of assertions has two purposes: –It can help to provide documentation of your code: Pre- and Post- conditions are an important part of the documented specifications of your code. –More complex methods would be difficult to “walk through” without some kind of commenting to indicate the progression of the logic.

20. Summer 2007CISC121 - Prof. McLeod20 Invariants – Triangle Example Remember the example of the triangles? It contains a logic error, but no syntax errors – it compiles and runs fine. It took many random test cases to determine that there was a logic error. Here is the code with assertions (squished…):

21. Summer 2007CISC121 - Prof. McLeod21 // pre: a,b,c > 0 and form a triangle public static String testTriangle (int a, int b, int c){ if (a == b) { if (b == c) { return "equilateral";} //inv1: a=b, b=c,  a=c else { return "isosceles";} //inv2: a=b, b  c,  a  c } else { if (b == c) { return "isoscles";} //inv3: a  b, b=c,  a  c else { return "scalene";} //inv4: a  b, b  c, a  c or a=c } } //end testTriangle // post: all possibilities have been tested Not so!

22. Summer 2007CISC121 - Prof. McLeod22 Invariants – Triangle Example – Cont. Now it is easier to see that not all possibilities have been tested. A situation can be reached where: a  b, b  c, but a=c is unknown. So there is a break in the logic between inv4 and the post condition.

23. Summer 2007CISC121 - Prof. McLeod23 Program Correctness - Cont. In Java versions > 1.4, assertions can be put in the code using the “ assert ” command, where they can actually do something useful. –Use “ assert ” when you are having problems debugging a particular piece of code. –You can use a compilation switch to tell the compiler to ignore all assertions when it does the final compile on your code – this way you don’t have to take them out of the source code!

24. Summer 2007CISC121 - Prof. McLeod24 The Java assert Keyword Syntax: assert expression1; assert expression1: expression2; expression1 must evaluate to a boolean result. For the second syntax, expression2 provides a String for the AssertionError that will be thrown when expression1 evaluates to false.

25. Summer 2007CISC121 - Prof. McLeod25 Using Assertions in Code - Cont. By default, code is compiled with the assert command being treated as a comment - so they do not have to be removed when not needed. You have to tell the compiler to “enable assertions” for them to work. Make sure that your assert statement is passive. It should not “do anything” with variable contents or change how the program runs. –In this way, ignoring the assertions should not affect the program.

26. Summer 2007CISC121 - Prof. McLeod26 Using assert, Cont. How is using assert different from just throwing an exception directly? –It is easier to do, and the invoking method does not have to worry about catching an exception. –You have the option of compiling and running your program in such a way that assertions can be ignored, speeding up the execution of your code. During program development, enable assertions. Once done, disable them. You can leave all your assert statements in your source code!

27. Summer 2007CISC121 - Prof. McLeod27 Aside – Using Assertions in Eclipse To add the command line parameter: “-ea” for “enable assertions” –Go to “Run” on the menu bar, then choose “Run…”. –In the window that opens, choose the “Arguments” tab and enter “-ea” (without the quotes) in the “VM arguments” box. This parameter gets reset when you exit Eclipse. To set permanently: –Go to “Window”, “Preferences…”, “Java”, “Installed JREs” and choose “jre1.6.0” and then click on the “Edit” button. Add “-ea” to “Default VM Arguments”.

28. Summer 2007CISC121 - Prof. McLeod28 Best Reference on Assertions http://java.sun.com/j2se/1.5.0/docs/guide/languag e/assert.html

29. Summer 2007CISC121 - Prof. McLeod29 Creating a Data Structure Why create our own data structures when there are so many pre-defined in the Java API already? (Lets have a look in java.util in the API docs…) To learn how they are put together. Avoid including extra methods that are not needed. (Tighter, more efficient code.) Specific structure for our requirements, not using a generic structure. Avoid privacy leaks.

30. Summer 2007CISC121 - Prof. McLeod30 Comparison of Arrays, ArrayLists and Linked Lists Arrays can be useful because: –The convenient “ [] ” notation allows immediate access to any element in the array. –Arrays can directly hold primitive types, as well as objects. –Primitive type storage is memory efficient, since the use of a Wrapper class is not necessary.

31. Summer 2007CISC121 - Prof. McLeod31 Comparison of Arrays, ArrayLists and Linked Lists - Cont. Arrays can be a problem because: –The size of the array must be known or at least estimated before the array can be used. –Increasing the size of an array can be very time intensive. How would you do this? –Arrays can only use a contiguous block of memory. When a new element is inserted into an array, all elements above the new one must be shifted up.

32. Summer 2007CISC121 - Prof. McLeod32 Comparison of Arrays, ArrayLists and Linked Lists – Cont. ArrayLists are useful because: –Sizing is no longer a problem. –They are built-in to the java.util class. –They inherit many useful methods. –ArrayList (The generic ArrayList class.) elements do not need to be cast back to the original element type. –Automatic boxing and un-boxing in Java >= 5.0

33. Summer 2007CISC121 - Prof. McLeod33 Comparison of Arrays, ArrayLists and Linked Lists – Cont. An ArrayList can be a problem because: –Arrays are still used (in the background). –Every re-sizing of the ArrayList causes a time lag, since a new array must be created in another block of memory and all the elements copied over. –Element insertion is just as time-consuming as with arrays, and possibly even worse if the ArrayList has to be resized. –It can only store Objects, not primitive types. –Do not have the handy “ [] ” notation, only methods.

34. Summer 2007CISC121 - Prof. McLeod34 Linked Lists A singly linked list consists of Objects called “nodes” that contain data and a link to the next node in the list: A node is defined in one class, and another class, the linked list class, contains the “ head ” and “ tail ” pointers. More detail shortly! 15 head 105 null 20 tail

35. Summer 2007CISC121 - Prof. McLeod35 Comparison of Arrays, ArrayLists and Linked Lists – Cont. Linked lists are useful because: –Can store primitive types or Objects or any combination of the above. –A node can be anywhere in memory. The list does not have to occupy a contiguous memory space. –List size is only limited by available memory, and does not have to be declared first. –No empty nodes. –The adding, insertion or deletion of list elements or nodes can be accomplished with the minimal disruption of neighbouring nodes.

36. Summer 2007CISC121 - Prof. McLeod36 Comparison of Arrays, ArrayLists and Linked Lists – Cont. Problems with linked lists include: –A node is not necessarily an efficient storage Object (in terms of memory usage), since it must hold links to other nodes in addition to the data item(s). –In order to access any one node in a linked list, all links must be followed from the “head” of the list to get to that certain node. Nothing like the “ [] ” notation of arrays.

37. Summer 2007CISC121 - Prof. McLeod37 Singly Linked List - Node Class public class IntNode { public int info; // a data value public IntNode next; // a link // constructors public IntNode (int i) { this(i, null); } public IntNode (int i, IntNode n) { info = i; next = n; } } // end IntNode

38. Summer 2007CISC121 - Prof. McLeod38 Singly Linked List – Cont. The “data value” could just as easily be an Object (of any kind): public class GNode { public Object info; //a data Object public GNode next; // a link // constructors public GNode (Object newInfo) { this(newInfo, null); } public GNode (Object newInfo, GNode n) { info = newInfo;// should clone newInfo… next = n; } } // end GNode

39. Summer 2007CISC121 - Prof. McLeod39 For simplicity, we will continue to consider a link holding an int value, “ info ”. For example, create a linked list of three integers, 10, 8 and 50: Singly Linked List – Cont.

40. Summer 2007CISC121 - Prof. McLeod40 Singly Linked List – Cont. First statement: IntNode p = new IntNode(10); As usual, this operation takes place in four stages: p info: next: p 10 p null p 10 null (i) (ii) (iii) (iv)

41. Summer 2007CISC121 - Prof. McLeod41 The above initialization uses the first constructor, which sets the value of info to 10 and sets the value of next to null. The next node is created using p.next = new IntNode(8); Singly Linked List – Cont.

42. Summer 2007CISC121 - Prof. McLeod42 Singly Linked List – Cont. p.next = new IntNode(8); p 10 null p 10 null 8 p 10 null 8 p 108 null

43. Summer 2007CISC121 - Prof. McLeod43 The last node (50) is added using: p.next.next = new IntNode(50); Singly Linked List – Cont. p 10850 null

44. Summer 2007CISC121 - Prof. McLeod44 Singly Linked List – Cont. Note that the last node always contains null. Right now, the list is only accessible through the variable “ p ”, so the cumbersome chain of “ next ”’s must be used to get at the individual elements. (What happens to the list if you coded “ p = null; ”?) Introduce another class that will keep track of the head and tail positions of the list:

45. Summer 2007CISC121 - Prof. McLeod45 public class IntSLList { // A “singly linked // list with a head and tail” private IntNode head; private IntNode tail; public IntSLList () { head = null; tail = null; } public void addToHead (int aNum) { head = new IntNode(aNum, head); if (tail == null) tail = head; } // more methods to be developed! } // end IntSLList

46. Summer 2007CISC121 - Prof. McLeod46 Singly Linked List - Node Class (again) public class IntNode { public int info; // a data value public IntNode next; // a link // constructors public IntNode (int i) { this(i, null); } public IntNode (int i, IntNode n) { info = i; next = n; } } // end IntNode

47. Summer 2007CISC121 - Prof. McLeod47 Singly Linked List – Cont. Create a list using: IntSLList list = new IntSLList(); null head tail list

48. Summer 2007CISC121 - Prof. McLeod48 Singly Linked List – Cont. list.addToHead(5); // step i list.addToHead(10); // step ii list.addToHead(15); // step iii 5 null list head tail 10 head tail 5 null 15 head tail 105 null IntNode’s

49. Summer 2007CISC121 - Prof. McLeod49 Singly Linked List – Cont. Now either end of the linked list can be located using the head or tail pointers, without using a cumbersome chain of next ’s.

50. Summer 2007CISC121 - Prof. McLeod50 Singly Linked List – Cont. Simplify notation. This: Is the same as: 15 head tail 105 null 15 head tail 105 null

51. Summer 2007CISC121 - Prof. McLeod51 Singly Linked List – Cont. Mechanism of adding another node: list.addToHead(20); addToHead method: public void addToHead (int aNum) { head = new IntNode(aNum, head); if (tail == null) tail = head; }

52. Summer 2007CISC121 - Prof. McLeod52 Singly Linked List – Cont. 15 head tail 105 null 15 head 105 null 20 15 head 105 null 20 15 head 105 null 20 tail

53. Summer 2007CISC121 - Prof. McLeod53 Singly Linked List – Cont. A method to add a new node to the tail of the list: public boolean isEmpty() { return head == null; } public void addToTail (int aNum) { if (!isEmpty()) { tail.next = new IntNode(aNum); tail = tail.next; else { head = new IntNode(aNum); tail = head; } } // end addToTail

54. Summer 2007CISC121 - Prof. McLeod54 Singly Linked List – Cont. list.addToTail(-5); 15 head 105 null 20 tail 15 head 105 null 20 tail -5 15 head 105 null 20 tail -5 null 15 head 10520 tail -5 null 15 head 10520 tail -5 null

55. Summer 2007CISC121 - Prof. McLeod55 Singly Linked List – Cont. Why not use: tail = new IntNode(aNum); instead of: tail.next = new IntNode(aNum); tail = tail.next; ? How would you add a node at the end of the linked list without a tail pointer? Does it make sense to sort a linked list? Can a node be inserted in the middle of the list, as easily as at the head or tail? Why would you want to?

56. Summer 2007CISC121 - Prof. McLeod56 Singly Linked List – Use of Inner Classes The node object, IntNode, is a public class and its attributes ( info and next ) are public. This is necessary so that the IntSLList class can use the node class. This is not good encapsulation practice. But if the class IntNode and its attributes are declared private, how can they be used by the linked list class?

57. Summer 2007CISC121 - Prof. McLeod57 Use of Inner Classes - Cont. Remember how private attributes are available (their “scope”) anywhere inside a class, but not outside the class? In fact, within the class, it does not matter if an attribute is private or public. Re-define IntSLList as:

58. Summer 2007CISC121 - Prof. McLeod58 Use of Inner Classes – Cont. public class IntSLList { private IntNode head; private IntNode tail; private class IntNode { private int info; private IntNode next; public IntNode (int i) { this(i, null); } public IntNode (int i, IntNode n) { info = i; next = n; } } // end IntNode // rest of IntSLList methods, constructors } // end IntSLList

59. Summer 2007CISC121 - Prof. McLeod59 Use of Inner Classes – Cont. Note that even though the inner class is private it can be used by IntSLList because it has been defined inside of this class. Or, the scope of IntNode is anywhere inside the IntSLList class. IntNode and its attributes are *not* available outside IntSLList. Much Better!

60. Summer 2007CISC121 - Prof. McLeod60 Writing Linked List Methods Note that each method must work for: –An empty list, –A list with just one node, and –A list with two or more nodes. We have methods to: –Create a list (the constructor) –Add to the head of the list –Check for an empty list –Add to the tail of the list What other methods would be useful?

61. Summer 2007CISC121 - Prof. McLeod61 Singly Linked List - Other Methods Deleting a head node. Deleting all nodes! Deleting an inner node (not head or tail). Deleting a tail node. Others: –Searching for a certain node. –Counting nodes. –Adding a inner node (“insertion”, but why?)

62. Summer 2007CISC121 - Prof. McLeod62 Singly Linked List - Deleting Nodes Note that a deleting method may or may not return the data value or a link to the data Object that it has deleted. We will assume that the deleting method returns the value. The calling method can choose not to do anything with this value. Note that these deleting methods will return a value of -1 if the list is empty. What else could we do here?

63. Summer 2007CISC121 - Prof. McLeod63 Deleting the Head Node public int removeFromHead () { if (isEmpty()) return -1; int i = head.info; if (head.next == null) { head = null; tail = null; } else head = head.next; return i; } // end removeFromHead

64. Summer 2007CISC121 - Prof. McLeod64 Deleting the Head Node, Cont. 15 head tail 105 null 15 head tail 105 null After head = head.next; What happens to the node with 15?

65. Summer 2007CISC121 - Prof. McLeod65 Deleting All Nodes public void clearList() { if (!isEmpty()) { head = null; tail = null; } // end if } // end clearList Nodes that are no longer “pointed to” are garbage collected!

66. Summer 2007CISC121 - Prof. McLeod66 First, locate the node, then delete it. It is way too big a method to show on this slide!! See the next one: Deleting the Node that Contains the Value “delNum”

67. Summer 2007CISC121 - Prof. McLeod67 public void delete (int delNum) { // does not return i if (!isEmpty()) if (head==tail && delNum==head.info) { head = null; tail = null;} // only 1 node else if (delNum == head.info) // delete first node, more nodes in list head = head.next; else { IntNode pred = head; IntNode temp = head.next; while (temp != null && temp.info != delNum) { pred = pred.next; temp = temp.next; } // end while if (temp != null) { pred.next = temp.next; if (tail == temp) tail = pred; } // end if } // end else } // end delete method

68. Summer 2007CISC121 - Prof. McLeod68 Deleting an Inner Node - An Example list.delete(10); 15 head 10520 tail -5 null 15 head 10520 tail -5 null 15 head 10520 tail -5 null pred temp pred temp predtemp pred.next = temp.next;

69. Summer 2007CISC121 - Prof. McLeod69 Deleting an Inner Node – Iterators Note the use of the pred and temp objects in the delete method: –(“Java jargon”) These are called “iterators” because they are used to move through the list.

70. Summer 2007CISC121 - Prof. McLeod70 Deleting a Tail Node So how is this going to work? How can the tail pointer be moved up to the preceding node? 15 head 105 null 20 tail

71. Summer 2007CISC121 - Prof. McLeod71 Deleting a Tail Node - Cont. Since there is no link from the tail node to the previous node, the only way is to iterate through the entire list, starting from the head, until the tail is reached. (How can you tell when you have reached the tail?) Two iterators must be used (Why?), as in the delete method:

72. Summer 2007CISC121 - Prof. McLeod72 public int removeTail () { int i = -1; if (!isEmpty()) { i = tail.info; if (head == tail) { head = null; tail = null;} else { IntNode pred = head; IntNode temp = head.next; while (temp.next != null) { pred = pred.next; temp = temp.next; } // end while tail = pred; tail.next = null; } // end else } // end if return i; } // end removeTail method

73. Summer 2007CISC121 - Prof. McLeod73 Deleting a Tail Node - Cont. That was a lot of work! Deleting the tail node this way is more time consuming than deleting an inner node. Would it not be nice if the tail node already had a link pointing to the previous node? No problem! Create a doubly linked list.

74. Summer 2007CISC121 - Prof. McLeod74 Doubly Linked Lists public class IntDLList { private IntDLNode head; private IntDLNode tail; private class IntDLNode { private int info; private IntDLNode next; private IntDLNode prev; // new link! public IntDLNode (int aNum) { this(aNum, null, null); } public IntDLNode (int aNum, IntDLNode n, IntDLNode p) { info = aNum; next = n; prev = p; } } // end IntDLNode // IntDLList constructors and methods } // end IntDLList

75. Summer 2007CISC121 - Prof. McLeod75 Doubly Linked List – Cont. Structure: head 20 tail null 105 null next prev

76. Summer 2007CISC121 - Prof. McLeod76 Doubly Linked List – Cont. To add a node to the tail of the list: // better add a constructor too! public IntDLList () { head = null; tail = null; } public boolean isEmpty () { return head == null; } public void addToTail (int aNum) { if (!isEmpty()) { tail = new IntDLNode(aNum, null, tail); tail.prev.next = tail; } else { head = new IntDLNode(aNum); tail = head; } } // end addToTail

77. Summer 2007CISC121 - Prof. McLeod77 Doubly Linked List – Cont. dLList.addToTail(-10); head 20 tail null 105 null head 20 tail null 105 null -10 null head 20 tail null 105-10 null -10 null After “ new …”: After tail.prev.next = tail; After tail=…;

78. Summer 2007CISC121 - Prof. McLeod78 Doubly Linked List – Cont. To remove the tail node: public int removeFromTail () { int i = -1; if (!isEmpty()) { i = tail.info; if (head == tail) { // one node in list head = null; tail = null; } else { tail = tail.prev; tail.next = null; } } // end if return i; } // end removeFromTail

79. Summer 2007CISC121 - Prof. McLeod79 Doubly Linked List – Cont. int temp = dLList.removeFromTail(); head 20 tail null 105-10 null After tail = tail.prev; Before head 20 tail null 105-10 null After tail.next = null; head 20 tail null 105 null -10 null temp is -10

80. Summer 2007CISC121 - Prof. McLeod80 Doubly Linked List – Cont. Now the removeFromTail method is much easier. So, adding or deleting head or tail nodes is “easy” - which operations will require iteration? Any operation that involves a node other than the head or tail!

81. Summer 2007CISC121 - Prof. McLeod81 Sample Code See IntDLList.java, for example.