Question

Step 4

Develop a class with only a main method in it:

public class QueueDemo {

public static void main(String[ ] args) {

/*   Inside of this main method do the following:

Create a reference to a QueueInterface<String> called myQueue and have it refer to a new object of the ImprovedQueue<String> class

    

     Call the enqueue method on myQueue passing the String value of “A”

Call the enqueue method on myQueue passing the String value of “B”

Call the enqueue method on myQueue passing the String value of “C”

Call the enqueue method on myQueue passing the String value of “D”

Create a String variable called discard and sets it value to the value that is returned from a call to dequeue on myQueue

Set the value of discard to the value that is returned from a call to dequeue on myQueue

Create a loop that continues as long as the queue is not empty and inside this loop create a variable called front that is set each time through the loop to the value that is returned from a call to dequeue on myQueue and then the value of front is printed each time through the loop

*/  

}

}

Answer 1

main() logic :

• Create a reference to QueueInterface<String> call it myQueue
• store a new ImprovedQueue<String> object in myQueue.
• Insert "A", "B" , "C" , "D" into myQueue using enqueue() method.
• call dequeue() and store the returned element inside a String variable discard.
• Loop until myQueue.isEmpty() returns true
  • 1.) call dequeue and store the returned value in front
  • 2.) print front

implementation:

public class QueueDemo{
   public static void main(String[] args){
       QueueInterface<String> myQueue;
       myQueue = new ImprovedQueue<String>();
       myQueue.enqueue("A");
       myQueue.enqueue("B");
       myQueue.enqueue("C");
       myQueue.enqueue("D");
       String discard = myQueue.dequeue();
       while(!myQueue.isEmpty()){
           String front = myQueue.dequeue();
           System.out.println(front);
       }
   }
}

the complete program:

• I think I answered all the 4 steps in your previous posts. So here is the complete implementation:

interface QueueInterface<T>{

public boolean isEmpty();

public T dequeue();

public void enqueue(T element);

}

class QueueNode<T> {
   private T info;
   private QueueNode<T> link;
   public QueueNode(T i){
       this.info = i;
       this.link = null;
   }
   public void setInfo(T i){
       this.info = i;
   }
   public T getInfo(){
       return this.info;
   }
   public void setLink(QueueNode<T> q){
       this.link = q;
   }
   public QueueNode<T> getLink(){
       return this.link;
   }

}

class ImprovedQueue<T> implements QueueInterface<T>{
   private QueueNode<T> front;
   public ImprovedQueue(){
       this.front = null;
   }
   public boolean isEmpty(){
       if(this.front==null)
           return true;
       else
           return false;
   }
   public T dequeue(){
       if(isEmpty())
           return null;
       QueueNode<T> temp = front;
       front = front.getLink();
       temp.setLink(null);
       return temp.getInfo();
   }
   public void enqueue(T element){
       QueueNode<T> newNode = new QueueNode<T>(element);
       if(isEmpty())
           this.front = newNode;
       else{
           QueueNode<T> temp = front;
           while(temp.getLink()!=null)
               temp = temp.getLink();
           temp.setLink(newNode);
       }
   }

}

public class QueueDemo{
   public static void main(String[] args){
       QueueInterface<String> myQueue;
       myQueue = new ImprovedQueue<String>();
       myQueue.enqueue("A");
       myQueue.enqueue("B");
       myQueue.enqueue("C");
       myQueue.enqueue("D");
       String discard = myQueue.dequeue();
       while(!myQueue.isEmpty()){
           String front = myQueue.dequeue();
           System.out.println(front);
       }
   }
}

output:

IB C D