无法将节点<E>转换成节点<E>？

Question

我只是做一些练习，从我的书之一，我很好奇为什么我收到以下错误在日食：

Type mismatch: cannot convert from type DoublyLinkedList.Node<E> to DoublyLinkedList.Node<E>

代码：

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<E>（用于DoublyLinkedList）。

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

private class MyListIter implements ListIterator<E> 

，但你做了它MyListIter<E>，这是重新定义E到的东西比E是DoublyLinkedList用户不同（隐式E extends Object与E extends Comparable<E>） 。

我认为Node将正常运行，是因为它是一个嵌套类（与static关键字），并没有从DoublyLinkedList继承E定义。但是，它很可能是有意义这里将其声明为一个非静态内部类的DoublyLinkedList（​​）一样MyListIter。

此外，你应该让E是一个类型，它是某种类型的通过声明为E extends Comparable<? super 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为节点和G为MyListIter。然后错误信息会说Type mismatch: cannot convert from type DoublyLinkedList.Node<E> to DoublyLinkedList.Node<G>。 ColinD建议的解决方案是。如果你愿意，你可以离开Node<F>静态，修复所有实例将具有相同的实际类型参数。