Use Array To Implement Queue With Size(bounded)

/*
note, here we use the concept of circle array: so head and tail could be in the middle of it.
head index is the 1st real value; tail index is the 1st available slot
    h       t
[...1 2 3 4 ....]
head: the first added value, the 1st index of meaningful value.
tail: points to the first available position to add new element
size: # of elements in array
when offer new element:
1) use the tail index
2) tail++. tricky: if tail++ == array.length: means the array is full(index out of bound), then move tail to 0
3) size++

when pop element:
1) return the head value
2) head++ tricky: if head++ == array.length(index out of bound) then move head to 0
3) tail--
4) size--
* */
public class UseArrayImplementQueueWithSize {
    private int headIndex ;
    private int tailIndex ;
    private int size; //number of real value in array
    private int[] array ; //the underlying buffer

    public UseArrayImplementQueueWithSize(int cap) {
        array = new int[cap] ;
        headIndex = 0;
        tailIndex = 0 ;
        size = 0 ;
    }

    //add to the tailIndex
    public boolean offer(int val){
        //this means array reaches to the limit. adding number will causing losing number
        if (size == array.length){
            return false ;
        }
        array[tailIndex] = val ;
        if (tailIndex +1 == array.length){
            tailIndex = 0 ;
        } else {
            tailIndex++ ;
        }
        size++;
        return true ;
    }

    //remove from the head, the hole will be filled with garbage value .
    public Integer poll(){
        //means there is no real value
        if (this.size == 0){
            return null ;
        }
        int value = array[headIndex] ;
        if (headIndex + 1 == array.length){
            headIndex = 0 ;
        } else {
            headIndex ++;
        }
        size-- ;
        return value ;
    }

    public Integer peek(){
        if (this.size == 0){
            return null ;
        }
        return array[headIndex] ;
    }

    public boolean isEmpty(){
        return this.size <= 0 ;
    }

    public int getSize(){
        return this.size ;
    }


    public static void main(String[] args) {
        UseArrayImplementQueueWithSize queue = new UseArrayImplementQueueWithSize(5) ;
        queue.offer(5);
        queue.offer(3);
        System.out.println(queue.size); //2
        System.out.println(queue.poll()); //5
        System.out.println(queue.offer(4)); //true
        System.out.println(queue.poll()); //3
    }
}