接口Java类方法未初始化
所以我有一个类赋值，我创建的类实现了一个接口
主要目标是实现一种新的队列，该队列只接受队列中对象的一个副本，如果一个元素已排队，并且该元素已存在于队列中，则队列将保持不变，并包含一个方法moveToBack，该方法允许您对队列中的一个元素取消优先级
我班上有几个问题，我很难解决
1）我的NoDupes类两次从队列接口继承时出现问题，但当我试图通过取消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;
}
}
# 1 楼答案
对于第一个问题，
NoDupsDePrioritizeQueue的类声明刚刚被破坏。我觉得你复制粘贴了一些错误的东西。你的措辞暗示你不知何故让这件事发生了，我完全不相信这毫无意义。这是在声明一个类，它复制了接口的名称（由于名称冲突，接口永远不会编译），并扩展了另一个类，然后。。。第二行是向后/断开的（同样，它永远不会编译）。我想这应该是
这声明了类
NoDupsDePrioritizeQueue，扩展了一个类并实现了接口