Implement the deque(double-ended queue) ADT using a doubly linked list

A deque is a double-ended queue that supports insertion and deletion at both the front and the rear of the queue.
For this program, I implemented the deque ADT using a doubly linked list. As below

public class ListDeque<AnyType> 
{
    /** *//**
     * This is the doubly-linked list node.
     */
    private static class Node<AnyType>
    {
        public Node( AnyType d, Node<AnyType> p, Node<AnyType> n )
        {
            data = d; prev = p; next = n;
        }
        
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;
    }

    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;
    private int theSize;
    
    public ListDeque()
    {
       beginMarker = new Node<AnyType>( null, null, null );
       endMarker = new Node<AnyType>( null, beginMarker, null );
       beginMarker.next = endMarker;
       
       theSize = 0;
    }


    /** *//**
     * Returns the number of items in this collection.
     * @return the number of items in this collection.
     */
    public int size( )
    {
        return theSize;
    }


    /** *//**
     * Returns true if this collection is empty.
     * @return true if this collection is empty.
     */ 
    public boolean isEmpty( )
    {
        return (theSize == 0);
    }


    /** *//**
     * Returns the first element of the deque
     * 
     */
    public AnyType first()
    {
        if(size() == 0)
            throw new QueueEmptyException("Empty Queue");
            
        return beginMarker.next.data;        
    }


    /** *//**
     * Returns the last element of the deque
     * 
     */
    public AnyType last()
    {
        if(size() == 0)
            throw new QueueEmptyException("Empty Queue");
            
        return endMarker.prev.data;
    }


    /** *//**
     * Inserts e at the beginning (as the first element) of the deque
     * 
     */
    public void insertFirst(AnyType e)
    {
        Node<AnyType> newNode = new Node<AnyType>( e, beginMarker, beginMarker.next );
        newNode.prev.next = newNode;
        newNode.next.prev = newNode;         
        theSize++;
    }


    /** *//**
     * Inserts e at the end (as the last element) of the deque
     * 
     */
    public void insertLast(AnyType e)
    {
        Node<AnyType> newNode = new Node<AnyType>( e, endMarker.prev, endMarker );
        newNode.prev.next = newNode;
        newNode.next.prev = newNode;         
        theSize++;
    }


    /** *//**
     * Removes and returns the first element of the deque
     * 
     */
    public AnyType removeFirst()
    {
        if(size() == 0)
            throw new QueueEmptyException("Empty Queue");
            
        AnyType temp = beginMarker.next.data;
        
        beginMarker.next = beginMarker.next.next;
        beginMarker.next.prev = beginMarker;
        
        theSize--;
        
        return temp;        
    }


    /** *//**
     * Removes and returns the last element of the deque
     * 
     */
    public AnyType removeLast()
    {
        if(size() == 0)
            throw new QueueEmptyException("Empty Queue");
            
        AnyType temp = endMarker.prev.data;
        
        endMarker.prev = endMarker.prev.prev;
        endMarker.prev.next = endMarker;
        
        theSize--;
        
        return temp;
    }
}

This program can throw an exception when removing element from empty linkedlist.
This is the definition of the exception, which extends its super class.

public class QueueEmptyException extends RuntimeException {  
  public QueueEmptyException(String err) {
    super(err);
  }
}

Main program which used to test the ListDeque program.

public class Main6
{
    public static void main(String[] args)
    {
        ListDeque<Integer>  deck = new ListDeque<Integer>();

        deck.insertFirst(new Integer(3));
        deck.insertFirst(new Integer(5));
        // (5,3)
        System.out.println(deck.removeFirst()); // prints 5
        // (3)
        deck.insertLast(new Integer(7));
        // (3,7)
        System.out.println(deck.removeFirst()); // prints 3
        //(7)
        System.out.println(deck.removeLast()); // prints 7
        // ()
        deck.insertFirst(new Integer(1));
        // (1)
        System.out.println(deck.first()); // prints 1
        // (1)
        deck.insertFirst(new Integer(5));
        // (5,1)
        System.out.println(deck.last());  // prints 1
        // 
        System.out.println(deck.removeFirst()); // prints 5
        // (1)
        deck.insertLast(new Integer(7));
        // (1,7)
        System.out.println(deck.removeFirst()); // prints 1
        //(7)
        System.out.println(deck.removeLast()); // prints 7
        // ()
        
        try
        {
            Integer a = deck.removeFirst();
            System.out.println(a);
        }
        catch (Exception ex)
        {
            System.err.println(ex);
        }

    }
}