1 / 81

CISC121 – Lecture 6

CISC121 – Lecture 6. Last time: Encapsulation Javadoc documentation Testing and Debugging. 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. You Will Need To:.

madra
Download Presentation

CISC121 – Lecture 6

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. CISC121 – Lecture 6 • Last time: • Encapsulation • Javadoc documentation • Testing and Debugging CISC121 - Prof. McLeod

  2. 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. CISC121 - Prof. McLeod

  3. 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 24th, 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. CISC121 - Prof. McLeod

  4. 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.) CISC121 - Prof. McLeod

  5. 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. CISC121 - Prof. McLeod

  6. 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. CISC121 - Prof. McLeod

  7. 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”. CISC121 - Prof. McLeod

  8. 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…) CISC121 - Prof. McLeod

  9. Program Correctness • 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. CISC121 - Prof. McLeod

  10. 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. CISC121 - Prof. McLeod

  11. 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. CISC121 - Prof. McLeod

  12. 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 CISC121 - Prof. McLeod

  13. 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 CISC121 - Prof. McLeod

  14. 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: CISC121 - Prof. McLeod

  15. // 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 CISC121 - Prof. McLeod

  16. 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. CISC121 - Prof. McLeod

  17. 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. CISC121 - Prof. McLeod

  18. 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! CISC121 - Prof. McLeod

  19. 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. CISC121 - Prof. McLeod

  20. 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…): CISC121 - Prof. McLeod

  21. // 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! CISC121 - Prof. McLeod

  22. 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. CISC121 - Prof. McLeod

  23. 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! CISC121 - Prof. McLeod

  24. 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. CISC121 - Prof. McLeod

  25. 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. CISC121 - Prof. McLeod

  26. 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! CISC121 - Prof. McLeod

  27. 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”. CISC121 - Prof. McLeod

  28. Best Reference on Assertions • http://java.sun.com/j2se/1.5.0/docs/guide/language/assert.html CISC121 - Prof. McLeod

  29. 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. CISC121 - Prof. McLeod

  30. 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. CISC121 - Prof. McLeod

  31. 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. CISC121 - Prof. McLeod

  32. 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<T> (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 CISC121 - Prof. McLeod

  33. 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. CISC121 - Prof. McLeod

  34. 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! tail head 20 15 10 5 null CISC121 - Prof. McLeod

  35. 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. CISC121 - Prof. McLeod

  36. 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. CISC121 - Prof. McLeod

  37. 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 CISC121 - Prof. McLeod

  38. 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 CISC121 - Prof. McLeod

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

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

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

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

  43. Singly Linked List – Cont. • The last node (50) is added using: p.next.next = new IntNode(50); p 10 8 50 null CISC121 - Prof. McLeod

  44. 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: CISC121 - Prof. McLeod

  45. 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 CISC121 - Prof. McLeod

  46. 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 CISC121 - Prof. McLeod

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

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

  49. 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. CISC121 - Prof. McLeod

  50. Singly Linked List – Cont. • Simplify notation. This: • Is the same as: head 15 10 5 null tail tail head 15 10 5 null CISC121 - Prof. McLeod

More Related