summer 2007cisc121 - prof. mcleod1 cisc121 – lecture 6 last time: –encapsulation –javadoc...

Summer 2007 CISC121 - Prof. McLeod 1

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:• 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.


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.)


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.


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.


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”.


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…)


• 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


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.


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.


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


Pre- & Post- Conditions - Cont.• Add pre- and postconditions:

// pre: n is >= 2public 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


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:


// pre: n is >= 2public 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 primereturn 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


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 postconditions, and thus prove that the post condition is true, then you have proved the “correctness” of your program.


Invariants - Cont.• In essence, the process is all about forming a

contract between the pre- and postconditions.

• 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.


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!


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.


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…):


// pre: a,b,c > 0 and form a trianglepublic 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, bc, ac } else { if (b == c) { return "isoscles";} //inv3: ab, b=c, ac else { return "scalene";} //inv4: ab, bc, ac or a=c }} //end testTriangle// post: all possibilities have been tested Not so!


Invariants – Triangle Example – Cont.• Now it is easier to see that not all possibilities

have been tested. A situation can be reached where: ab, bc, but a=c is unknown.

• So there is a break in the logic between inv4 and the post condition.


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!


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.


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.


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!


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”.


Best Reference on Assertions• http://java.sun.com/j2se/1.5.0/docs/guide/

language/assert.html


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.


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.


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.


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



• 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.


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

10 5null

20

tail



• 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.



• 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.


Singly Linked List - Node Classpublic class IntNode {

public int info; // a data valuepublic IntNode next; // a link

// constructorspublic IntNode (int i) { this(i, null); }public IntNode (int i, IntNode n) {

info = i;next = n;

}} // end IntNode


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 Objectpublic GNode next; // a link

// constructorspublic GNode (Object newInfo) { this(newInfo, null); }public GNode (Object newInfo, GNode n) {

info = newInfo; // should clone newInfo…next = n;

}} // end GNode


• 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.


Singly Linked List – Cont.• First statement:

IntNode p = new IntNode(10);• As usual, this operation takes place in four

stages:

pinfo:next:

p10

p10null

p10null

(i) (ii)

(iii) (iv)


• 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.p.next = new IntNode(8);

p10null

p10null

8

p10null

8null

p10 8

null


• The last node (50) is added using:

p.next.next = new IntNode(50);


p10 8 50

null


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:


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


Singly Linked List - Node Class (again)public class IntNode {

public int info; // a data valuepublic IntNode next; // a link

// constructorspublic IntNode (int i) { this(i, null); }public IntNode (int i, IntNode n) {

info = i;next = n;

}} // end IntNode



• Create a list using:

IntSLList list = new IntSLList();

nullnull

headtail

list


Singly Linked List – Cont.list.addToHead(5); // step ilist.addToHead(10); // step iilist.addToHead(15); // step iii

5null

list

head

tail

10head

tail

5null

15head

tail

10 5null

IntNode’s


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.


Singly Linked List – Cont.• Simplify notation. This:

• Is the same as:

15head

tail

10 5null

15head

tail

10 5null



• 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;

}



15head tail

10 5null

15head

10 5null

20

15head

10 5null

20

15head

10 5null

20

tail

tail

tail


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


Singly Linked List – Cont.list.addToTail(-5);

15head

10 5null

20tail

15head

10 5null

20tail

-5

15head

10 5null

20tail

-5null

15head

10 520tail

-5null

15head

10 520tail

-5null



• 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?


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?


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:


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


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!


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?


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?)


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?


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


Deleting the Head Node, Cont.

15head

tail

10 5null

15

head tail

10 5null

• After head = head.next;

• What happens to the node with 15?


Deleting All Nodespublic void clearList() {

if (!isEmpty()) {head = null;tail = null;

} // end if} // end clearList

• Nodes that are no longer “pointed to” are garbage collected!


• 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”


public void delete (int delNum) { // does not return iif (!isEmpty())if (head==tail && delNum==head.info) { head = null; tail = null;} // only 1 nodeelse 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


Deleting an Inner Node - An Examplelist.delete(10);

15

head

10 520tail

-5null

15head

10 520tail

-5null

15head

10 520tail

-5null

pred temp

pred temp

pred temp

pred.next = temp.next;


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.


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

10 5null

20

tail


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:


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 ifreturn i;

} // end removeTail method


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.


Doubly Linked Listspublic 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


Doubly Linked List – Cont.• Structure:

head20

tail

null

10 5nullnext

prev


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


Doubly Linked List – Cont.

dLList.addToTail(-10);head

20tail

null

10 5null

head20

tail

null

10 5null

-10null

head

20

tail

null

10 5 -10null

-10null

After “new…”:

After tail.prev.next = tail;

After tail=…;


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 listhead = null; tail = null;}else {tail = tail.prev;tail.next = null;}} // end ifreturn i;

} // end removeFromTail


Doubly Linked List – Cont.

int temp = dLList.removeFromTail();head

20

tail

null

10 5 -10null

After tail = tail.prev;

Before

head

20

tail

null

10 5 -10null

After tail.next = null;head

20

tail

null

10 5null

-10null

temp is -10


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!


Sample Code• See IntDLList.java, for example.

summer 2007cisc121 - prof. mcleod1 cisc121 – lecture 6 last time: –encapsulation –javadoc...

Documents