Cannot convert from Node<E> to Node<E>?

I am just doing some practice from one of my books, and I was curious about why I am getting the following error in eclipse:

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

Code:

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;
}


}

I commented where exactly I am getting the error in 3 different locations. If you can provide any feedbac开发者_运维知识库k, I'd appreciate it. My book doesn't address it and I have searched around and can't really seem to get the answer i'm looking for.

---

You've declared two different generic types: E (for Node) and E extends Comparable<E> (for DoublyLinkedList).

The main issue here is probably MyListIter, which is a non-static inner class and as such automatically inherits DoublyLinkedList's definition of E. Because it inherits the definition of E, you should just be declaring it as

private class MyListIter implements ListIterator<E>

but you've made it MyListIter<E>, which is redefining E to something different than the E that DoublyLinkedList users (implicit E extends Object vs. E extends Comparable<E>).

I think Node should work as-is since it is a nested class (with the static keyword) and doesn't inherit the definition of E from DoublyLinkedList. However, it'd probably make sense here to declare it as a non-static inner class of DoublyLinkedList (private class Node) the same as MyListIter.

Also, you should probably allow E to be a type that is a subtype of some type that implements Comparable by declaring it as E extends Comparable<? super E>.

---

It looks like you're getting this error because you're redefining E in your Node nested class. Since it's a static nested class, it has no direct relationship to the parent class DoublyLinkedList. It might make more sense to make the class non-static so that E continues to have meaning within it. For example:

private class Node {

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

...

EDIT: as ColinD noted, MyListIter should similarly not redeclare E as a type parameter. Changing this like with Node should fix the issue.

---

ColinD is right (+1).

To understand what's going on, imagine not using the same formal type parameter 3 times, but E for DoublyLinkedList, F for Node and G for MyListIter. Then the error message would say Type mismatch: cannot convert from type DoublyLinkedList.Node<E> to DoublyLinkedList.Node<G>. The solution is the one ColinD suggested. If you want, you can leave Node<F> static, with the fix all instances will have the same actual type parameter.