无法从 Node转换到节点？

Question

我只是在做我的一本书中的一些练习，我很好奇为什么我在 eclipse 中收到以下错误：

类型不匹配：无法从 DoublyLinkedList.Node类型转换；到 DoublyLinkedList.Node

代码：

import java.util.Iterator;
    import java.util.ListIterator;
    import java.util.NoSuchElementException;


public class DoublyLinkedList<E extends Comparable<E>> implements Iterable<E>{

 private int size = 0;
 private Node<E> head;
 private Node<E> tail;

/** Returns a list iterator object for the list at 
 * the specified index
 */

 public DoublyLinkedList(){


}



private static class Node<E> {

    Node<E> next = null;
    Node<E> prev = null;
    E data;

    public Node(E dataItem){
        data = dataItem;
    }

    public Node(E dataItem, Node<E> previous, Node<E> nextNode){
        this(dataItem);
        prev = previous;
        next = nextNode;
    }

}


private class MyListIter<E> implements ListIterator<E>{

    private Node<E> lastReturned; // a link reference to the last item that was returned
    private Node<E> nextItem; // a link reference to the next item in the list
    /** The index of the current position */ 
    private int index = 0;

    public MyListIter(int pos){
        if (pos < 0 || pos > size)
            throw new IndexOutOfBoundsException("Invalid index: " + index);
        lastReturned = null;
        if (pos == size){
            index = size;
            nextItem = null;
        } else { // otherwise we will start at the beginning of the list, and loop until the position in the argument
            nextItem = head; // ERROR
            for (index = 0; index < pos; index++){
                nextItem = nextItem.next; // next item will always reference the list node that is called by the next method
            }

        }
    }

    @Override
    public void add(E element) {
        if (head == null){
            Node<E> newNode = new Node<E>(element);
            head = newNode; // ERROR
            tail = head;
        }


    }
    @Override
    public boolean hasNext() {
        return nextItem != null; // just checks to make sure there is a node following the current node
    }
    @Override
    public boolean hasPrevious() {
        return (nextItem == null && size != 0) || nextItem.prev != null;
    }
    @Override
    public E next() {
        if (!hasNext())
            throw new NoSuchElementException("There is no node at that location");
        lastReturned = nextItem;
        nextItem = nextItem.next;
        index++;
        return lastReturned.data;
    }
    @Override
    public int nextIndex() {
        // TODO Auto-generated method stub
        return 0;
    }
    @Override
    public E previous() {
        if (!hasPrevious())
            throw new NoSuchElementException();
        if (nextItem == null) // the iterator is at the end of the list
            nextItem = tail; // therefore, the nextItem is at the tail, so the previous is the tail. ERROR HERE TOO
        else
            nextItem = nextItem.prev;
        lastReturned = nextItem;
        index--;
        return lastReturned.data;
    }
    @Override
    public int previousIndex() {
        // TODO Auto-generated method stub
        return 0;
    }
    @Override
    public void remove() {
        // TODO Auto-generated method stub

    }
    @Override
    public void set(E arg0) {
        // TODO Auto-generated method stub

    }



}


@Override
public Iterator<E> iterator() {
    // TODO Auto-generated method stub
    return null;
}


}

我评论了我在 3 个不同位置收到错误的确切位置。如果您能提供任何反馈，我将不胜感激。我的书没有解决这个问题，我四处搜寻，似乎无法真正得到我正在寻找的答案。

Answer 1

您声明了两种不同的泛型类型：E（对于 Node）和 E extends Comparable（对于 DoublyLinkedList代码>）。

这里的主要问题可能是 MyListIter，它是一个非静态内部类，因此自动继承 DoublyLinkedList 的 E 定义。因为它继承了 E 的定义，所以您应该将其声明为

private class MyListIter implements ListIterator<E>

MyListIter，这会重新定义 E 与 DoublyLinkedList 用户的 E 不同（隐式 E extends Object 与 E extends可比较）。

我认为Node应该按原样工作，因为它是一个嵌套类（带有static关键字）并且不继承<的定义来自 DoublyLinkedList 的 code>E。但是，在这里将其声明为与 MyListIter 相同的 DoublyLinkedList（private class Node）的非静态内部类可能是有意义的>。

另外，您可能应该允许 E 成为某种类型的子类型，通过将其声明为 E 来实现 Comparable扩展比较。

Answer 2

看来您收到此错误是因为您在 Node 嵌套类中重新定义 E 。由于它是一个静态嵌套类，因此它与父类DoublyLinkedList没有直接关系。将类设置为非静态可能更有意义，以便 E 继续在其中有意义。例如：

private class Node {

Node next = null;
Node prev = null;
E data;

...

编辑： 正如 ColinD 所指出的，MyListIter 同样不应将 E 重新声明为类型参数。使用 Node 进行更改应该可以解决该问题。

Answer 3

ColinD 是对的（+1）。

为了理解发生了什么，想象一下不使用相同的形式类型参数 3 次，而是使用 E 代表 DoublyLinkedList，F 代表 Node，G 代表 MyListIter。然后错误消息会显示 Typemismatch:cannotconvertfromtypeDoublyLinkedList.Node;到 DoublyLinkedList.Node。 ColinD 提出了解决方案。如果需要，您可以将 Node保留为静态，修复后所有实例都将具有相同的实际类型参数。