Question

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

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，这是一个非静态的内部类，因此会自动继承DoublyLinkedList对E的定义。因为它继承了E的定义，所以您应该将其声明为

private class MyListIter implements ListIterator<E>

但您已将其设为MyListIter<E>，这会将E重新定义为与E个DoublyLinkedList用户（隐式E extends Object vs的E extends Comparable<E>不同的内容。Node）。

我认为 static应该按原样运行，因为它是一个嵌套类（使用E关键字）并且不会继承{{}的定义1}}来自DoublyLinkedList。但是，这里将它声明为DoublyLinkedList（private class Node）与MyListIter相同的非静态内部类可能是有意义的。

此外，您应该允许E成为某种类型的子类型类型，通过将其声明为Comparable来实现E extends Comparable<? super E>。< / p>

Answer 2

您似乎收到此错误，因为您正在重新定义E嵌套类中的Node。由于它是静态嵌套类，因此它与父类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>静态，修复所有实例将具有相同的实际类型参数。

无法从Node <e>转换为Node <e>？</e> </e>

3 个答案: