1DV507, Programming and Data Structures, Spring 2017

Assignment 2: Data Structures, JUnit, and JavaFX (1)

Problems?
Do not hesitate to ask your teaching assistant at the practical meetings (or Jonas at the lectures) if you have any problems. You can also post a question in the assignment forum in Moodle.

Prepare Eclipse for course 1DV507 and Assignment 2
Inside your Java project named 1DV507, create a new package with the name YourLnuUserName_assign2 and save all program files for this assignment inside that package. Later on, when submitting your assignment, you should submit a zipped version of this folder/package.

General Assignment Rules

• Use English! All documentation, names of variables, methods, classes, and user instrutions, should be in English.
• Each exercise that involves more than one class should be in a separate package with a suitable (English!) name. For example, in Exercise 1, create a new sub package named queue inside your package YourLnuUserName_assign2 and save all .java files related to this exercise inside this package.
• All programs asking the user to provide some input should check that the user input is correct and take appropriate actions if it is not.

Lecture 4 - Simple Data Structures

• Exercise 1
  
  A Queue is a FIFO (first in, first out) data structure. Consider the following queue interface:

  public interface Queue {  
     public int size();                     // current queue size 
     public boolean isEmpty();              // true if queue is empty 
     public void enqueue(Object element);   // add element at end of queue 
     public Object dequeue();               // return and remove first element. 
     public Object first();                 // return (without removing) first element 
     public Object last();                  // return (without removing) last element 
     public String toString();              // return a string representation of the queue content
     public Iterator<Object> iterator();    // element iterator
  }
  

  The iterator iterates over all elements of the queue. Operations not allowed on an empty queue shall generate an unchecked exception.
  
  Tasks:
  • Create a linked implementation LinkedQueue.java of the interface Queue. Use the head-and-tail approach.
  • Write also a program QueueMain.java showing how all methods work.
  • Create Javadoc comments in the code and generate good-looking and extensive HTML documentation for the interface and the class. All public class members shall be documented.
  Notice:
  • The implementation shall be linked, i.e. a sequence of linked nodes where each node represents an element.
  • You are not allowed to use any of the predefined collection classes in the Java library.
  • In the report, the HTML pages generated by the classes Queue and LinkedQueue shall be attached. Attach no other HTML pages!
• Exercise 2 (VG Task)
  A straight forward arrray based implementation of the Queue interface above would use an Object array (that grows on demand) and two indices first and last to keep track of the array positions where to remove an element on dequeue (return and increase position first), and where to add an element on enqueue (insert at and increase position last). The problem with this approach is that after (say) 100 dequeue we will have that first = 100 and 100 non-used elements (positions 0 to 99) that never will be used again. That is, a waste of memory.
  

  Your task is to provide an array based Queue implementation (ArrayQueue) that avoids this problem by treating the array like a circular array in which array indices larger than the array size ``wrap around'' to the beginning of the array. That is,

  • When, after a number of enqueues, index last reaches array.length, you should move last to position 0 and start to reuse the first part of the array.
  • Later on, after an even larger number of dequeues, you will reach the point where index first reaches array.length. Then, move first to position 0 (and you have returned to the initial configuration where all the queue elements are stored between first and last).
  • Finally, the array is full when last, after one or more ``wrap arounds'', reaches first. In that case you should resize the array and restore the order such that first equals 0.

  This approach is called a queue implementation based on circular arrays. Look it up on the Internet to get all details.

Lecture 5 - JUnit Testing

• Exercise 3
  Write a JUnit test for the class LinkedQueue in Exercise 1.
• Exercise 4 (VG Task)
  Modify the Queue test in Exercise 3 so that it can also handle the ArrayQueue class from Exercise 2. We do not want two separate tests. We want one test that can be used for any implementation of the Queue interface with just a minimum of modifications.

Lecture 6 - JavaFX (Part 1)

• Exercise 5
  Write a program OneTwoThree.java which creates a JavaFX Application window containing the following.
  1. Three panes with different colors.
  2. Each pane should contain a word: One, Two or Three.
  3. One should be placed in the upper left corner, Two should be placed in the middle of the panel and Three in the lower right corner.
  Choose size and color of the panes to make it look nice.
  
  

• Exercise 6
  Create a class RandomPanel (extends BorderPane) containing two panes. One of the panes should contain a button with the text New Random. When the button is pressed a random number in the interval 1-100 is generated and shown in the other pane. Try to change the size of the text so that the number 100 fills the pane. Also, write a test program RandomMain.java starting an Application containing a RandomPanel.
• Exercise 7
  Write a GUI program ColorDisplay.java. When the button ”Display Color” is pressed, three integers (red, green, blue) are read and the color of the upper pane is changed according to the values of the integers. Use three components of the type TextField to read the integers. The picture below shows how the execution of the program can look.
  
  

  If erroneous values of the integers are read, an error message should be printed and the upper pane should not be updated. The most important thing is that the program is working properly. It is also important for the program to have a good structure to make it easy to follow and to understand. Divide big methods and big classes into smaller ones, if necessary.

Submission