ADT Stack with a doubly circular linked list I have managed to implement an ADTStack with a circular doubly linked list. I would like to know whether there are things I could have done better or, I should improve.

public class QueueCircularDLL&lt;T&gt; implements ADTQueue&lt;T&gt; {    
    private ListElement&lt;T&gt; head;
    private ListElement&lt;T&gt; tail;

    public QueueCircularDLL(){
        head=null;
        tail=null;
    }

    public void enq (T element){
        ListElement&lt;T&gt;newElement=new ListElement&lt;T&gt;(element);
        if (empty()){
            head= newElement;
            tail= head;
        }

        tail.setNextElement(newElement);
        newElement.setPrevElement(tail);
        tail=tail.getNextElement();
        tail.setNextElement(head);
        head.setPrevElement(tail);

    }

    public void deq(){
        if (empty()){
            throw new RuntimeException("queue is empty");
        }

        if (head==tail){
            //head=null;
            head=null;
            tail=null;

        }
        else{
        head=head.getNextElement();
        head.setPrevElement(tail);
        tail.setNextElement(head);
        }

    }

    public T front(){
        if(empty()){
            return null;
        }
        return head.getElement();
    }

    public boolean empty(){
        return (head==null);
    }

    private static class ListElement&lt;T&gt;{
        private T element = null;
        private ListElement&lt;T&gt; nextElement = null;
        private ListElement&lt;T&gt; prevElement = null;

        public ListElement(T element) {
            this.element = element;
        }

        public T getElement() {
            return element;
        }

        public ListElement&lt;T&gt; getNextElement() {
            return nextElement;
        }

        public void setNextElement(ListElement&lt;T&gt; element) {
            this.nextElement = element;
        }
        //für zirkuläre doppelt verkettete liste
        public ListElement&lt;T&gt;getPrevElement(){
            return prevElement;
        }
        // für zirkuläre doppelt verkette liste
        public void setPrevElement(ListElement&lt;T&gt; element){
            this.prevElement=element;
        }



    }

    public static void main(String[] args) {
        QueueCircularDLL&lt;Integer&gt; queue = new QueueCircularDLL&lt;Integer&gt;();

        for (int i = 0; i &lt; 10; ++i) {
            queue.enq(i);
        }

        while (!queue.empty()) {
            System.out.println(queue.front());
            queue.deq();
        }
    }
}
The class doesn't expose a method that let's users benefit from the circular property.
The enq, deq, front, empty methods could work just fine without the circular property.
As such, it's an unnecessary complexity.
If you want to use a circular linked list,
then expose some methods that need or benefit from the circular property.

The class QueueCircularDLL&lt;T&gt; implements the ADTQueue&lt;T&gt; interface,
but it's not clear which methods belong to the interface.
It's strongly recommended to make that clear using the @Override annotation.

In front, instead of returning null when the list is empty,
a more common practice is to throw java.util.NoSuchElementException,
as done by the various linked list and queue implementations in the JDK.