时间戳

首页 > 解决方案 > 如何解决：类型 Node 不是通用的；它不能用参数参数化

java - 如何解决：类型 Node 不是通用的；它不能用参数参数化

问题描述

我不知道如何解决： Node 类型不是通用的；它不能用参数参数化......你也可以从标题中读取它。当我尝试编译我的程序时，一切正常，但我想解决这个问题。我看过：

每当我声明节点 ex 时，我都会收到该错误：

Node<Integer> node2 = null;//error on node Node<Integer>
        node2=new Node<Integer>(5, node2);//error on node Node<Integer>
        node2=new Node<Integer>(6, node2);//error on node Node<Integer>
        node2=new Node<Integer>(7, node2);//error on node Node<Integer>

这是我的节点类：

// Nodo per realizzare liste concatenate.
public class Node<T> {
    // Elemento intero contenuto in questo nodo.
    private T elem;
    // Nodo successore, o null se e' l'ultimo nodo della lista concatenata.
    private Node  <T> next;

    // Crea un nuovo nodo con valore @elem e successore @next.
    public  Node  (T elem, Node  <T> next) {
        this.elem = elem;
        this.next = next;
    }

    /**
     * @return int
     */
    // Ritorna l'elemento contenuto in questo nodo.
    public  T getElem() {
        return this.elem;
    }
    /**
     * @param p
     * @param q
     * @return boolean
     */
    public   boolean included(Node<T> p, Node <T> q) {
        boolean ret = true;
        boolean exit = false;
        Node<T> tempP = p;
        Node <T> tempQ = q;
        if (p == null || q == null) {
            if (q == null) {
                ret = false;
            }
            ret = true;
        } else {
            while (tempP != null && ret) {
                exit = false;
                while (tempQ != null && !exit) {
                    if (tempP.getElem() == tempQ.getElem()) {
                        exit = true;
                        tempQ = tempQ.next;
                    } else {
                        tempQ = tempQ.next;
                    }
                }
                tempP = tempP.next;
                if (exit) {
                    ret = true;
                } else {
                    ret = false;
                }
            }
        }

        return ret;
    }

    /**
     * @param p
     * @param x
     * @return int Ritona un intero che rappresenta le occorenze di x nella lista p
     */

    public  int occurrences(Node <T> p, T x) {
        if (p.next == null)
            return (p.elem == x) ? 1 : 0;
        return findOcc(p, x, 0);
    }

    /**
     * @param p
     * @param x
     * @param i
     * @return int
     */
    private  int findOcc(Node<T> p, T x,int i) {
        int count = i;
        if (p.next == null) {
            return count = count + uguali(p.elem, x);
        } else {
            count = findOcc(p.next, x, count);
            count = count + uguali(p.elem, x);
            return count;
        }

    }

    /**
     * @param elem
     * @param x
     * @return int
     */
    private   int uguali(T elem, T x) {
        return (elem == x) ? 1 : 0;
    }

    /**
     * @param p
     * @return Node
     */
    public Node <T> reverse(Node<T> p) {
        Node <T> ret = null;
        Node<T> tempP=p;
        ret = reverse(tempP, ret);
        return ret;
    }

    /**
     * @param p
     * @param ret
     * @return Node
     */
    private  Node <T> reverse(Node <T> p, Node<T>  ret) {
        Node <T> retElem = ret;
        if (p.next == null) {
            return new Node<T>(p.elem, retElem);
        } else {
            retElem = new Node<T>(p.elem, retElem);
            retElem = reverse(p.next, retElem);
            return retElem;
        }
    }

    /**
     * @param elem Cambia l'intero contenuto nel nodo al nuovo valore @elem.
     */

    public void setElem(T elem) {
        this.elem = elem;
    }

    /**
     * @return Node Ritorna il riferimento al nodo successore, oppure null se non
     *         c'e' un successore.
     */

    public  Node<T> getNext() {
        return this.next;
    }

    /**
     * @param next Cambia il riferimento al nodo successore con @next.
     */

    public void setNext(Node <T>next) {
        this.next = next;
    }
     
    public  int getSize(){
        return getSize(this) ;
    }
    
    private int getSize(Node<T> node) {
        return node==null?0:1+getSize(node.getNext());
    }

    public Node<T> listsLeng(Node<T> p){
        Node<T> ret = null;
        Node<T> temp=p;
        int size;
        while(temp!=null){
            size=getSize((Node<T>)temp.getElem());
            ret = new Node(size, ret);
            temp=temp.getNext();
        }

        return ret;
    }

    public void print() {
        Node<T>  ret = this;
        print(ret);
    }
    
    /** 
     * @param p
     */
    public void print(Node<T> p){
       if(p.getNext()==null){
        System.out.println(p.getElem());
       }else{
        print(p.getNext());
        System.out.println(p.getElem());
       }

    }
}

如果你想看看，试着看看你自己：https ://drive.google.com/file/d/1YkOQYtZIoipW996c3PhNCY_pfhdMctw8/view?usp=sharing

标签： java

解决方案

您尝试强制转换size=getSize((Node<T>)temp.getElem());但temp.getElem()类型为T，它不是Node<T>. 此外，在下一行中，ret = new Node(size, ret);您创建一个原始节点并尝试将sizetypeint放入您的 genericNode中。你应该重新考虑方法public Node<T> listsLeng(Node<T> p)。

编辑：在equals其他类（Set和DynamicQueue）中，你也做不安全的演员表。在TestDynamicQueue你做Node<Node>内部节点是原始的（未参数化）的地方。

推荐阅读