Si considerino le seguenti classi Java (per semplicita' utilizziamo eccezioni non controllate).

1) Si ridefinisca in Queue il metodo di Object
      public String toString()
      in modo da produrre una stampa "sensata" di una coda, ad esempio "<"+ gli elementi separati da virgole +">"
      
2) Si ridefinisca il metodo nelle classi eredi ArrayQueue e ListQueue in modo piu' efficiente, se possibile.

3) Si definisca in Queue un metodo 
        int size()
      che restituisce il numero di elementi nella coda.

4) Si ridefinisca il metodo nelle classi eredi ArrayQueue e ListQueue in modo piu' efficiente, se possibile.
      
3) Si definisca in Queue un metodo 
        void reverse()
      che rovescia la coda.

4) Si ridefinisca il metodo nelle classi eredi ArrayQueue e ListQueue in modo piu' efficiente, se possibile.


class EmptyQueueException extends RuntimeException{}
class FullQueueException extends RuntimeException {}
class IlegalArgumentException extends RuntimeException {}
 
abstract class Queue {
  abstract boolean isEmpty();
 abstract Object front( );
  abstract Object dequeue ();
  abstract Object enqueue( Object x );
  abstract void clear ();
  }
  
class ArrayQueue extends Queue {
    static final int DEFAULT_SIZE = 32;

    private Object [ ] theArray;
   private int        size, front, back;

    ArrayQueue( ) {
        theArray = new Object[ DEFAULT_SIZE ];
        size = 0;
        front = 0;
        back = -1;
    }

    boolean isEmpty( ) {
        return size == 0;
    }

    void clear( ) {
        size = 0;
        front = 0;
        back = -1;
    }

    Object front( )  {
        if ( isEmpty( ) )
            throw new EmptyQueueException( );
        return theArray[ front ];
    }

    Object enqueue( Object x )  {
	if ( x == null )
	    throw new IllegalArgumentException( );
        if ( size == theArray.length )
            throw new FullQueueException();
        size++;
        back = increment( back );
        return theArray[ back ] = x;
    }

     Object dequeue( ) {
        if ( isEmpty( ) )
            throw new EmptyQueueException( );
        size--;
        Object item = theArray[ front ];
        front = increment( front );
        return item;
    }

    private static int increment( int x ) {
        return (x + 1) % DEFAULT_SIZE;
    }
    


}


class ListNode {
    Object   element;
    ListNode next;

    ListNode( Object element) {
        this( element, null );
    }

 ListNode( Object element, ListNode next )  {
	if ( element == null )
	    throw new IllegalArgumentException( );
        this.element  = element;
        this.next     = next;
    }
}
class ListQueue extends Queue {
  private ListNode front, back;
    public boolean isEmpty( ) {
        return front==null;
    }

   public  void clear( ) {
  front=back=null;
      }

    Object front( )   {
        if ( isEmpty( ) )
            throw new EmptyQueueException( );
        return front.element;
    }

    Object enqueue( Object x ) {
	if ( x == null )
	    throw new IllegalArgumentException( );
	 if (isEmpty()) front=back=new ListNode(x);
	 else {
	   back.next=new ListNode(x);
	   back=back.next;
	   }
	   return x;
     }

     Object dequeue( )  {
        if ( isEmpty( ) )
            throw new EmptyQueueException( );
        Object x = front.element;
        if (front==back) back = null;
        front = front.next;
        return x;
    }
}

public class QueueTest {

  public static void main (String[] args) {
    Queue q = new ArrayQueue();
   for (int i = 1;i<=15;i++) q.enqueue(new Integer(i));
   System.out.println(q);
   System.out.println(q.size());
    for (int i = 1;i<=10;i++) q.dequeue();
   System.out.println(q);  
   System.out.println(q.size());
    for (int i = 16;i<=20;i++) q.enqueue(new Integer(i));
   System.out.println(q);
   System.out.println(q.size());
   q.reverse();
   System.out.println(q);
   q = new ListQueue();
   for (int i = 1;i<=15;i++) q.enqueue(new Integer(i));
   System.out.println(q);
   System.out.println(q.size());
    for (int i = 1;i<=10;i++) q.dequeue();
   System.out.println(q);  
   System.out.println(q.size());
    for (int i = 16;i<=20;i++) q.enqueue(new Integer(i));
   System.out.println(q);
   System.out.println(q.size());
    q.reverse();
   System.out.println(q);
   }
}