Java类方法没有初始化

Question

所以我有一个类分配，我创建的类实现了一个接口(interface)。

主要目标是实现一种新型队列，该队列仅接受队列中对象的单个副本，如果入队一个元素，并且该元素已存在于队列中，则队列将保持不变，并包括moveToBack 方法允许您取消队列中元素的优先级。

我的类(class)有几个问题无法解决。

1) 我的 NoDupes 类两次从 Queue 接口(interface)继承时存在问题，但是当我尝试通过消除 ArrayQueue 类中的继承来修复时，我无法让它运行

2)缺少在 moveToBack 方法中递增的循环，但是当我尝试修复与上一个问题相同的问题时。

3)foundValue 未初始化

4)display():当队列为空时不应打印空值。

5) 我不知道如何实现enqueue()。

以下是我正在尝试实现的类，任何帮助将不胜感激:

数组队列

public class ArrayQueue<T> implements QueueInterface<T> {

    private T[] queue; // circular array of queue entries and one unused location
    private int frontIndex;
    private int backIndex;
    private static final int DEFAULT_INITIAL_CAPACITY = 50;

    public ArrayQueue() {
        this(DEFAULT_INITIAL_CAPACITY);
    }

    public ArrayQueue(int initialCapacity) {
        queue = (T[]) new Object[initialCapacity + 1];
        frontIndex = 0;
        backIndex = initialCapacity;
    }

    public void enqueue(T newEntry) {
        if (isArrayFull()) {
            doubleArray();
        }

        backIndex = (backIndex + 1) % queue.length;
        queue[backIndex] = newEntry;
    }

    public T getFront() {
        T front = null;

        if (!isEmpty()) {
            front = queue[frontIndex];
        }

        return front;
    }

    public T dequeue() {
        T front = null;

        if (!isEmpty()) {
            front = queue[frontIndex];
            queue[frontIndex] = null;
            frontIndex = (frontIndex + 1) % queue.length;
        }

        return front;
    }

    public boolean isEmpty() {
        return frontIndex == ((backIndex + 1) % queue.length);
    }

    public void clear() {
        if (!isEmpty()) { // deallocates only the used portion
            for (int index = frontIndex; index != backIndex; index = (index + 1) % queue.length) {
                queue[index] = null;
            }
            queue[backIndex] = null;
        }

        frontIndex = 0;
        backIndex = queue.length - 1;
    }

    private boolean isArrayFull() {
        return frontIndex == ((backIndex + 2) % queue.length);
    }

    private void doubleArray() {
        T[] oldQueue = queue;
        int oldSize = oldQueue.length;

        queue = (T[]) new Object[2 * oldSize];

        for (int index = 0; index < oldSize - 1; index++) {
            queue[index] = oldQueue[frontIndex];
            frontIndex = (frontIndex + 1) % oldSize;
        }

        frontIndex = 0;
        backIndex = oldSize - 2;
    }
}

<小时/>

public interface NoDupsDePrioritizeQueueInterface <T> extends
                                                      QueueInterface<T> {

    /*
     * Task: Moves the given entry to the back of the queue. If the entry is not
     * in the queue, just add it at the end.
     * 
     * @param entry the item to move or add
     */
    public void moveToBack(T entry);

    /*
     * * Task: displays the contents of the queue (to be used for testing);
     * specifies the front and back of the queue
     */
    public void display();
}

<小时/>

public interface QueueInterface<T> {

    public void enqueue(T newEntry);

    /**
     * Task: Removes and returns the entry at the front of the queue.
     *
     * @return either the object at the front of the queue or, if the queue is
     *         empty before the operation, null

     */
    public T dequeue();

    /**
     * Task: Retrieves the entry at the front of the queue.
     *
     * @return either the object at the front of the queue or, if the queue is
     *         empty, null
     */
    public T getFront();

    /**
     * Task: Detects whether the queue is empty.
     *
     * @return true if the queue is empty, or false otherwise
     */
    public boolean isEmpty();

    /** Task: Removes all entries from the queue. */
    public void clear();
} // end QueueInterface

我的实现:

public class NoDupsDePrioritizeQueueInterface<T>
    extends ArrayQueue
    implements NoDupsDePrioritizeQueue<T> { //note, this was glitched before edit

    public NoDupsDePrioritizeQueue() {
        super();
    }// end NoDupsDePrioritizeQueue

    public NoDupsDePrioritizeQueue(int initialCapacity) {
        super(initialCapacity)
    }// end NoDupsDePrioritizeQueue

    public void moveToBack(T newEntry) {
        boolean found = false;
        int start = frontIndex;
        int back = backIndex;
        int index = 0;
        if (!isEmpty()) {
            //searching if newEntry is already present in the queue. If it is present,
            note its index. while (start != back) {
                if (newEntry.equals(queue[start])) {
                    found = true;
                    index = start;
                    break;

                }
                start = (start + 1) % queue.length;
            }
            // the condition does not check queue[back] as the loop exits then. 
            //Hence we evaluate it separately. 
            if (newEntry.equals(queue[start])) {
                found = true;
                index = start;
            }
            //if its not found in the queue, do normal enqueue
            if (found == false) {
                enqueue(newEntry);
            } else {
                //shifting all elemets till the backindex and replacing the last element 
                //with the newEntry 
                foundValue = queue[index];
                while ((index + 1) % queue.length <= backIndex) {
                    queue[index] = queue[(index + 1) % queue.length];
                }
                queue[backIndex] = foundValue;
            }

        } else {
            enqueue(newEntry);
        }
    }
    //end moveToBack

    // displaying the queue without destroying it
    public void display() {
        int start = frontIndex;
        int back = backIndex;
        while (start != back && !isEmpty()) {
            System.out.println(queue[start]);
            start = (start + 1) % queue.length;
        }
        System.out.println(queue[start]);

    }

}

其他部分

/**
 * A class that implements the ADT queue by using an expandable circular
 * array
 * with one unused location.
 */
public class ArrayQueue<T> {
    protected T[] queue; // circular array of queue entries and one unused location
    protected int frontIndex;
    protected int backIndex;
    protected static final int DEFAULT_INITIAL_CAPACITY = 50;

    public ArrayQueue() {
        this(DEFAULT_INITIAL_CAPACITY);
    }

    public ArrayQueue(int initialCapacity) {
        queue = (T[]) new Object[initialCapacity + 1];
        frontIndex = 0;
        backIndex = initialCapacity;
    }

    public void enqueue(T newEntry) {
        //enqueue needs to be changed to eliminate duplicates
        if (isArrayFull()) {
            doubleArray();
        }
        boolean found = false;
        //if its emtpy array, do normal enqueue operation
        if (!isEmpty()) {
            int start = frontIndex;
            int back = backIndex;
            //checking for duplicates by travelling through the array. however, we 
            //will miss queue[back] as the loop exits then.Hence we will search for it separately. 
            while (start != back) {
                //if found, simply exit
                if (newEntry.equals(queue[start])) {
                    found = true;
                    System.out.println("Element already exists");
                    return;
                }
                start = (start + 1) % queue.length;
            }
            if (newEntry.equals(queue[start])) {
                found = true;
                System.out.println("Element already exists");
                return;
            }
        }
        backIndex = (backIndex + 1) % queue.length;
        queue[backIndex] = newEntry;
    }

    public T getFront() {
        T front = null;
        if (!isEmpty()) {
            front = queue[frontIndex];
        }
        return front;
    }

    public T dequeue() {
        T front = null;
        if (!isEmpty()) {
            front = queue[frontIndex];
            queue[frontIndex] = null;
            frontIndex = (frontIndex + 1) % queue.length;
        }
        return front;
    }

    public boolean isEmpty() {
        return frontIndex == ((backIndex + 1) % queue.length);
    }

    public void clear() {
        if (!isEmpty()) { // deallocates only the used portion
            for (int index = frontIndex; index != backIndex; index = (index + 1) % queue.length) {
                queue[index] = null;
            }
            queue[backIndex] = null;
        }
        frontIndex = 0;
        backIndex = queue.length - 1;
    }

    private boolean isArrayFull() {
        return frontIndex == ((backIndex + 2) % queue.length);
    }

    private void doubleArray() {
        T[] oldQueue = queue;
        int oldSize = oldQueue.length;
        queue = (T[]) new Object[2 * oldSize];
        for (int index = 0; index < oldSize - 1; index++) {
            queue[index] = oldQueue[frontIndex];
            frontIndex = (frontIndex + 1) % oldSize;
        }
        frontIndex = 0;
        backIndex = oldSize - 2;
    }
}

Answer 1

对于你的第一个问题，NoDupsDePrioritizeQueue 的类声明刚刚被破坏。我认为您复制并粘贴了错误的内容。你的措辞暗示你以某种方式让它运行，我完全不相信。

public class NoDupsDePrioritizeQueueInterface<T> extends ArrayQueue
NoDupsDePrioritizeQueue<T> implements {

这没有任何意义。这是声明一个重复接口(interface)名称的类(由于名称冲突，它永远不会编译)，让它扩展另一个类，并且......第二行是向后/损坏的(同样，它永远不会编译)。我想这应该是

public class NoDupsDePrioritizeQueue<T> extends ArrayQueue
implements NoDupsDePrioritizeQueueInterface<T> {

这声明了类NoDupsDePrioritizeQueue，扩展了一个类并实现了接口(interface)。