Data structures: basic circular queue, and operation

/ ** 
 * circular queue 
* queue pointers directly disposed first head of queue elements, the last element of the queue a pointer to a tail end of, i.e., a reserved space in the queue is always
  * / 
class CircleQueue the implements Queue <Integer> {

    private Integer[] queueArray = null;

    private int first;
    
    private int tail;

    private int maxSize;

    public CircleQueue(int max){
        this.maxSize=max+1;
        this.queueArray = new Integer[maxSize];
    }
    
    
    @Override
    public int size() {
        return (tail-first+maxSize)%maxSize;
    }

    @Override
    public boolean isEmpty() {
        return tail==first;
    }

    @Override
    public boolean contains(Object o) {
        Integer integer = (Integer)o;
        for (int i = first; i!=tail; i++) {
            if (i==queueArray.length){
                i=0;
            }
            if (integer.equals(queueArray[i])){
                return true;
            }
        }
        return false;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int temFirst = first;
            @Override
            public boolean hasNext() {
                return tail!=temFirst;
            }

            @Override
            public Integer next() {
                int num = queueArray[temFirst];
                temFirst = (temFirst+1)%maxSize;
                return num;
            }
        };
    }


    @Override
    public boolean add(Integer integer) {
        if ((tail+1)%maxSize==first){
            System.out.println ( "queue is full, you can not add" );
             return  false ;
        }
        queueArray[tail]=integer;
        tail = (tail+1)%maxSize;
        return true;
    }


    @Override
    public Integer poll () {
         IF (isEmpty ()) {
             the throw  new new a RuntimeException ( "queue empty" );
        }
        int result = queueArray[first];
        first  = (first+1)%maxSize;
        return first;
    }

    @Override
    public Integer peek() {
        return queueArray[first];
    }
}

    public static void main(String[] args) {
        CircleQueue circleQueue = new CircleQueue(5);

        Scanner scanner = new Scanner(System.in);

        while (true){
            System.out.println ( ". 1: additive element" );
            System.out.println ( "2: Remove the element" );
            System.out.println ( "3: View head element" );
            System.out.println ( ". 4: traversing queue" );
            System.out.println ( "5: View the number of elements" );
            System.out.println ( ". 6: is empty" );
             int commend that = scanner.nextInt ();
             Switch (commend that) {
                 Case . 1 : {
                    System.out.println ( "Please output element" );
                     int NUM = scanner.nextInt ();
                    circleQueue.add(num);
                    break;
                }
                case 2:{
                    System.out.println(circleQueue.poll());
                    break;
                }
                case 3:{
                    System.out.println(circleQueue.peek());break;

                }
                case 4:{
                    for (Integer integer : circleQueue) {
                        System.out.printf("%d\t",integer);
                    }
                    System.out.println();
                    break;
                }
                case 5:{
                    System.out.println(circleQueue.size());break;

                }
                case 6:{
                    System.out.println(circleQueue.isEmpty());
                    break;
                }
            }
        }

    }