Как сделать не разрушительное исследование очереди в Java
Я помогаю своему сыну с колледжем, программируя класс, и я предполагаю, что мне нужен класс также. Он завершил присвоение, но я не полагаю, что он делает его лучший способ. К сожалению, я не могу заставить это работать с моим лучшим путем. Это ясно лучше, потому что это еще не работает.
Его просят реализовать некоторые методы для класса, который расширяет другой класс.
Ему сказали, что он должен использовать следующее определение класса, и он ничего не может изменить в ListQueue.
public class MyListQueue <AnyType extends Comparable<AnyType>> extends ListQueue<AnyType>
Вот то, что находится в ListQueue
// Queue interface
//
// ******************PUBLIC OPERATIONS*********************
// void enqueue( x ) --> Insert x
// AnyType getFront( ) --> Return least recently inserted item
// AnyType dequeue( ) --> Return and remove least recent item
// boolean isEmpty( ) --> Return true if empty; else false
// void makeEmpty( ) --> Remove all items
// ******************ERRORS********************************
// getFront or dequeue on empty queue
/**
* Protocol for queues.
*/
Хорошо я чувствую себя довольно хорошо о пересечении связанного списка в Паскале или C (показывая мой возраст), но никогда не работал на языке ООП прежде.
Когда я делаю попытку чего-то вроде этого
dummyQueue = this.front.next;
Я получаю следующую ошибку. * передняя сторона имеет частный доступ в ListQueue *
С которым я соглашаюсь, но кроме исключения из очереди объект, как я могу пересечь список, или иначе получать доступ к передней стороне, назад, следующий и предыдущий, которые являются всеми в ListQueue.
Образование ценилось бы.
Спасибо, David
3 ответа
Если я правильно вас понимаю, вы делаете что-то вроде этого:
MyListQueue<String> dummyQueue = new MyListQueue<String>();
dummyQueue = this.front.next;
Если так, то один из основных постулатов ООП - это инкапсуляция, т.е. сокрытие данных. Идея заключается в том, что пользователи вне класса не имеют доступа к внутреннему состоянию класса.
Если вы хотите определить размер очереди и не можете изменить ни интерфейс, ни реализацию, то одно, что вы можете сделать - это создать делегат очередь, которая перекрывает enqueue и dequeue для инкремента и декремента счетчика.
Если вы выбираете очередь, вы обычно хотите только ставить в очередь и удалять элементы. Вы хотите знать, пуста ли очередь, и хотите посмотреть на передний элемент, если он вам нужен, или оставить его для кого-то другого. Очередь - это своего рода буфер, который избегает блокировки, если отправитель быстрее получателя. С помощью очереди получатель может решить , когда читать следующую запись. Очередь может реализовать некоторую (на основе приоритета) сортировку и решить, какой элемент является передним.
Если вам нужны другие операции, например, обход списка, очередь может быть не лучшим выбором. Посмотрите на другие типы коллекций, возможно, на ArrayList.
Некоторые вещи можно сделать, вы можете создать подкласс ListQueue и переопределить некоторые методы. Итак, если вам нужен дополнительный метод size () , это может быть решением:
public class MyListQueue <T extends Comparable<T>> extends ListQueue<T> {
private size = 0;
public void enqueue(T element) {
size++;
super.enqueue(element);
}
public T dequeue() {
if (isEmpty()) {
return null; // that's a guess...
}
size--;
super.dequeue(element);
}
public int size() {
return size;
}
}
Я заменил AnyType на T, который встречается чаще.
Вы спросили: «Кроме удаления элемента из очереди, как я могу перемещаться по списку или иным образом получить доступ к переднему, заднему, следующему и предыдущему, которые все находятся в ListQueue».
В самом чистом смысле вы не должны быть способным к.
Идеализированная очередь обещает только несколько вещей:
- Вставить элементов в заднюю часть
- Извлечь элементов спереди
- (Возможно) Проверить передний элемент, if not empty
- (Возможно) Предикат пространства определения для pop и inspect , определение того, пуста ли очередь
Я предполагаю, что для момент, когда очередь не предназначена для использования ни с параллельными читателями (доступ к передней части одновременно), ни с параллельными читателями и писателями (доступ к задней и передней стороне в то же время).
Учитывая это определение, нет причин заглядывать «внутрь» очереди. Вы кладете вещи в одну сторону, а вынимаете из другой. Если вы принимаете во внимание ограничение размера очереди, вам может потребоваться дополнительный предикат пространства определения для операции push , чтобы определить, заполнена ли очередь. «Быть заполненным» имеет смысл только в том случае, если очередь ограничена. «Быть пустым» имеет значение только в том случае, если поток, вызывающий pop или inspect , не желает блокироваться.
Помимо этого, существует прагматическая идея очереди. Мы можем предположить, что это последовательность элементов, которая - за исключением проблем параллелизма - имеет наблюдаемый неотрицательный размер и может даже позволить посещать каждый элемент в последовательности.Некоторые очереди заходят так далеко, что позволяют удалять или переставлять элементы в позициях, отличных от начала последовательности. Однако на этом этапе мы больше не обсуждаем очередь. Мы обсуждаем последовательность, лежащую в основе очереди. Если нам нужен такой доступ, нам не нужна очередь. Нам нужна последовательность, которую мы хотим предложить другим частям программы в виде очереди .
Вот почему очереди обычно не являются конкретными типами в библиотеках структур данных. В C ++ тип std :: queue является декоратором для некоторого другого типа контейнера. В Java java.util.Queue - это интерфейс. Scala использует другой подход: class scala.collection.mutable.Queue - это расширение типа MutableList . Это похоже на подход, предусмотренный в задании вашего сына, но неясно, намеревался ли ваш ListQueue когда-либо позволить посторонним (включая подклассы) воспользоваться его "характером списка" - проникнуть в представление очереди для использования последовательность внутри.
Есть ли у вас требование посещать кого-либо, кроме начальника очереди? Необходимость сделать это ограничивает ваш выбор в отношении того, какие типы очередей могут вместить ваши потребляющие функции. Похоже, мы извлекаем неверные уроки из этого задания.