不能对非静态类型进行静态引用

Question

我正在用单链表学习Java。

我有一个工作链表，但它绑定到整数类型，现在我试图实现一个泛型链表通过改变所有的整数声明为泛型e

编译器一直抱怨它"不能对非静态类型E进行静态引用"。代码仍然在运行。有谁知道如何修复这个错误吗?

我认为这与泛型类型E是静态类型(如integer或double)还是引用类型(如String或其他类)有关。

public class TestingLinkedList<E> {

private E value;
private TestingLinkedList<E> next;
/*
 * Default Constructor
 * 
 * @param value an absolute E value for the current Node
 * 
 * @param next an absolute RecursiveLinkedList value for the current Node
 */
public TestingLinkedList(E value, TestingLinkedList next) {
    this.value = value;
    this.next = next;
}
/*
 * Constructor Empty, when user supplies an empty for the constructor uses
 * value = - 1 and next = null as input parameters
 * 
 * @param value an absolute int value for the current Node
 * @param next an absolute RecursiveLinkedList value for the current Node
 */
public static final TestingLinkedList EMPTY = new TestingLinkedList(null,null) 
{
    public TestingLinkedList remove(E n) {
        return this;
    };
    public String toString() {
        return "";
    };
};
/*
 * if the current node is null return false
 * else if current value is the chosen value
 * then return true. Otherwise call the contains
 * method of the next item in queue
 * 
 * @param value an absolute int value for the current Node
 * @param RecursiveLinkedList object of the remove item
 * */
public TestingLinkedList remove(E n) {
    if (value == n) {
        return next;
    }
    // Call the remove method of the next Node if the selected Node is not
    // the current node then construct and return the next method
    return new TestingLinkedList(value, next.remove(n));
}
/*
 * if the current node is null return false
 * else if current value is the chosen value
 * then return true. Otherwise call the contains
 * method of the next item in queue
 * 
 * @param value an absolute int value for the current Node
 * @param boolean
 * */
public boolean contains(E n) {
    if (next == null) {
        return false;
    }else if (value == n) {
        return true;
    } else {
        return next.contains(n);
    }
}
public String toString() {
    return value + "," + next.toString();
}

/*
 * 
 * Testing Methods for RecursiveLinkedList
 * 
 * */
public static void main(String[] args) {
    TestingLinkedList l = new TestingLinkedList(1,
            new TestingLinkedList(2, new TestingLinkedList(2,
                    new TestingLinkedList(3, new TestingLinkedList(4,
                            EMPTY)))));
    System.out.println(" Test to String Method : " + l.toString());
    System.out.println(" Test remove method " + l.remove(1).toString());
    System.out.println(" Test contains method "
            + String.valueOf(l.contains(4)));
}

}

Answer 1

public static final TestingLinkedList EMPTY = new TestingLinkedList(null,null)

应:

public static final TestingLinkedList<Integer> EMPTY
                                      = new TestingLinkedList<Integer>(null,null)

这违反了泛型，因为E的占位符是在构造时确定的，而且这是静态的，它不能使用E值。而是使用泛型方法:

public static <T> TestingLinkedList<T> empty() {
    return new TestingLinkedList<T>(null, null) {
        public TestingLinkedList remove(T n) {
            return this;
        }
        public String toString() {
            return "";
        }
    }
}