偷懒实现环形队列（数组） JAVA

数据结构——线性结构——》队列
大家知道队列最具体的体现就是银行排队，遵循先进先出。
那么实现方法有两种
1.基于数组实现
2.基于链表实现
在这里带来的是环形队列，是基于数组实现的。
大家知道，数组的初始化是固定的，不能像链表一样实现动态增加大小，所以，环形队列就是充分解决这个问题的，不至于，让数组是一次性的使用。
简单表示一下：
现在来展示代码：

public class Queue_By_RingArr {
    class queue_by_ringarr{
        int front=0;
        int rear=0;
        int ar[]=new int [5];
         int DatNumber=0;//用于记录队列中的元素个数
    }
    queue_by_ringarr Q=new queue_by_ringarr();
    /*
    添加 add
     */
    public void add(int index){
        //不满才能添加  所以先判断满
        if(empty(Q)){
            System.out.println("队列现在为满，不可添加元素！！！");
        }else {
            Q.ar[(Q.rear)%Q.ar.length]=index;
            Q.rear++;
            Q.DatNumber++;

        }
    }
    /*
    删除 remove  遵循队列的先进先出 所以不需要再传入数据
     */
    public void romove(){
        //当然，现在要判空，否则没有元素删除，就异常了
        if(full(Q)){
            System.out.println("队列为空，没有元素可以删除！！！");
        }else{
            Q.front++;//其实这里没有被删除，只是让该位置可以被再次赋值而已。当然，你也可以强制将该位置改为0，不过我觉得没意义。
            Q.DatNumber--;
        }
    }
    /*
    返回队列头元素 pop
     */
    public int pop(){
        return Q.ar[Q.front];
    }
    /*
    返回队列尾元素 show_rear
     */
    public int show_rear(){
        return Q.ar[(Q.rear-1)%Q.ar.length];
    }
    /*
    展示全部元素 Show
     */
    public void Show(){
        for(int i=Q.front;i<Q.rear;i++){
            System.out.print(" "+Q.ar[i%Q.ar.length]);
        }
    }
    /*
    判满 full
     */
    public boolean full(queue_by_ringarr Q){
        if(Q.DatNumber==0){
            return true;
        }else {
            return false;
        }
    }
    /*
    判满  empty
     */
    public boolean empty(queue_by_ringarr Q){
        if(Q.DatNumber==Q.ar.length){
            return true;
        }else {
            return false;
        }
     }

    public static void main(String[] args) {
       Queue_By_RingArr QBRA=new Queue_By_RingArr();
       QBRA.add(01);
       QBRA.add(02);
       QBRA.add(03);
        QBRA.add(04);
        QBRA.add(05);
        System.out.print("展示现在的队列");
        QBRA.Show();
        System.out.println();
        QBRA.romove();
        QBRA.romove();
        System.out.print("现在展示删除两个元素后的队列");
        QBRA.Show();
        System.out.println();
        QBRA.add(111);
        System.out.print("现在展示再次添加一个元素后的队列");
        QBRA.Show();
        System.out.println();
        System.out.println("现在展示 队列头"+QBRA.pop()+"  队列尾"+QBRA.show_rear());
        QBRA.add(112);
        System.out.print("现在队列再次被添加满");
        QBRA.Show();
        System.out.println();
        QBRA.add(113);
        QBRA.Show();
    }
}

运行结果：
从代码中，可以看出。我的偷懒其实就是判满（empty（））函数的判断。我没有使用队列头（front）和尾（rear）的关系来判断。而是，在这个队列中，我添加了一个属性——》DataNumber(记录数据的个数） 用它的大小是否和数组大小相等，来作为判满的条件。
我感觉这样好像也没有啥问题吧。。。
（感觉有影响的话，就是再次添加，不过我试了，没问题，嗯。）
还希望大佬多多指点。。