Methoden Moving Snake Forward

[AmsananKING]

Can someone help me with this,
I am right now working on a Snake program and I want to move the snake forward with the move forward, how can I do this ?

public class Queue<ContentType> {

    /* --------- Anfang der privaten inneren Klasse -------------- */

    public class QueueNode {

        private ContentType content = null;
        private QueueNode nextNode = null;

        /**
         * Ein neues Objekt vom Typ QueueNode<ContentType> wird erschaffen.
         * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
         *
         * @param pContent das Inhaltselement des Knotens vom Typ ContentType
         */
        public QueueNode(ContentType pContent) {
            content = pContent;
            nextNode = null;
        }

        /**
         * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
         * gesetzt.
         *
         * @param pNext der Nachfolger des Knotens
         */
        public void setNext(QueueNode pNext) {
            nextNode = pNext;
        }

        /**
         * Liefert das naechste Element des aktuellen Knotens.
         *
         * @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
         */
        public QueueNode getNext() {
            return nextNode;
        }

        /**
         * Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
         *
         * @return das Inhaltsobjekt des Knotens
         */
        public ContentType getContent() {
            return content;
        }

    }

    /* ----------- Ende der privaten inneren Klasse -------------- */

    public QueueNode head;
    protected QueueNode tail;

    /**
     * Eine leere Schlange wird erzeugt.
     * Objekte, die in dieser Schlange verwaltet werden, muessen vom Typ
     * ContentType sein.
     */
    public Queue() {
        head = null;
        tail = null;

    }

    /**
     * Die Anfrage liefert den Wert true, wenn die Schlange keine Objekte enthaelt,
     * sonst liefert sie den Wert false.
     *
     * @return true, falls die Schlange leer ist, sonst false
     */
    public boolean isEmpty() {
        if (head == null) {
            return true;
        }
        else {
            return false;
        }
    }

    /**
     * Das Objekt pContentType wird an die Schlange angehaengt.
     * Falls pContentType gleich null ist, bleibt die Schlange unveraendert.
     *
     * @param pContent
     *            das anzuhaengende Objekt vom Typ ContentType
     */
    public void enqueue(ContentType pContent) {
        if (pContent != null) {
            QueueNode newNode = new QueueNode(pContent);
            if (this.isEmpty()){
                head = newNode;
                tail = newNode;
            }

            else {
                tail.setNext(newNode);
                tail = newNode;   
            }

        }
    }

    /**
     * Das erste Objekt wird aus der Schlange entfernt.
     * Falls die Schlange leer ist, wird sie nicht veraendert.
     */
    public void dequeue() {
        if(!this.isEmpty()){
            head = head.getNext();
        }
    }

    /**
     * Die Anfrage liefert das erste Objekt der Schlange.
     * Die Schlange bleibt unveraendert.
     * Falls die Schlange leer ist, wird null zurueckgegeben.
     *
     * @return das erste Objekt der Schlange vom Typ ContentType oder null,
     *         falls die Schlange leer ist
     */
    public ContentType front() {
        if (this.isEmpty()){
            return null;
        } else {
            return head.getContent();
        }

    }

    private void pause() {
        try {
            Thread.sleep(500);
        } catch(Exception e) {}
    }
}

public class SnakeContent
{
    private int x,y;
    public SnakeContent(int x,int y){
    this.x=x;
    this.y=y;
    }
    public int X(){
    return x;
    }
    public int Y(){
    return y;
    }
    public void move(int dx,int dy){
    x=x+dx;
    y=y+dy;
    }
    public void setX(int x){this.x=x;}
    public void setY(int y){this.y=y;}
    @Override
    public String toString(){
    return "X: "+x+" "+"Y: "+y;
    }
}

public class Snake
{
    private Queue<SnakeContent> snakequeue=new Queue<SnakeContent>();   
    public SnakeContent head;
    private SnakeContent[] temp;
    /**
     * Konstruktor für Objekte der Klasse Snake
     */
    public Snake(int x,int y)
    {
       head=new SnakeContent(x,y);
       snakequeue.enqueue(head);
       for(int i=1;i<=10;i++){
        insertSnakeContent(new SnakeContent(x+i,y));
        }
      
    }
    public Queue<SnakeContent> getSnakeQueue(){
    return snakequeue;
    }
    public void insertSnakeContent(SnakeContent content){
    snakequeue.enqueue(content);
    }
  
}