Question

我正在制作一个单独的链表来学习Java。

我有一个工作链表但它绑定到整数类型，现在我试图通过将所有整数声明更改为泛型类型E来实现泛型类型链表。

编译器一直抱怨它“无法对非静态类型E进行静态引用”。代码仍在运行。有人知道如何解决这个错误“？

我认为它与泛型类型E是静态的整数还是双精度有关，或者它是否是像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 "";
        }
    }
}

单链表 - 不能对非静态类型进行静态引用

1 个答案: