需要有关未检查java操作的帮助吗

我自己也在学习算法，我尝试从头开始用泛型类型在

Java

中实现

LinkedList

。我有一个使用

Object

的版本，它运行得很好，但是当我用泛型类型更新它时，它会给出警告。有人能帮忙吗“未经检查或不安全的操作”是从哪里来的

class LinkedListGeneric <T> {
    private Node<T> head; 
    private int size;

    public LinkedListGeneric() {
       head = null;
       size = 0; 
    }

    public int size() {
        return size;
    }

    public void add (T data) {
        if (head == null) {
            head = new Node<T> (data);
            size = 1;
        }
        else {
            Node<T> temp = new Node<T> (data);
            search(size).setNext(temp);
            size++;
        }
    }

    public void add (T data, int position) {
        if (position > size + 1 || position <= 0) {
            System.out.println ("error.");
            return;
        }
        Node<T> temp = new Node<T> (data);
        if (position == 1) {
            temp.setNext(head);
            head = temp;
            return;
        }
        Node<T> prev = search(position - 1);
        temp.setNext(prev.getNext());
        prev.setNext(temp);
    }

    public void delete (int position) {
        if (position > size || position <= 0) {
            System.out.println ("error.");
            return;
        }
        if (position == 1) {
            size--;
            head = head.getNext();
            return;
        }
        Node<T> prev = search(position - 1);
        prev.setNext(prev.getNext().getNext());
        size--;
    }

    public T getValue (int position) {
        if (position > size || position <= 0) {
            System.out.println ("error.");
            return null;
        }
        Node<T> temp = search(position);
        return temp.getData();
        //return search(position).getData();
    }

    public int searchData(T data) {
        Node<T> temp = head;
        int position = 1;
        boolean flag = false;
        while (temp != null) {
            if (temp.getData() == data) {
                flag = true;
                break;
            }
            else {
                temp = temp.getNext();
                position++;
            }
        }
        if (flag) return position;
        else return -1;
    }

    public void print() {
        Node<T> temp = head;
        int position = 1;
        while (temp != null) {
            System.out.println("Node " + position + ": " + temp.getData());
            temp = temp.getNext();
            position++;
        }
    }

    private Node<T> search (int position) {
        Node temp = head;
        while (position > 0) {
            temp = temp.getNext();
        }
        return temp;
    }

    private class Node<T> {
        private T data;
        private Node<T> next;
        public Node() {
           this.data = null;
           next = null; 
        }

        public Node(T data) {
           this.data = data;
           next = null; 
        }

        public T getData() {
            return data;
        }

        public Node getNext() {
            return next;
        }
        public void setNext(Node next) {
            this.next = next;
        }
    }
}

类LinkedListGeneric{
专用节点头；
私有整数大小；
公共LinkedListGeneric（）{
head=null；
尺寸=0；
}
公共整数大小（）{
返回大小；
}
公共无效添加（T数据）{
if（head==null）{
head=新节点（数据）；
尺寸=1；
}
否则{
节点温度=新节点（数据）；
搜索（大小）.setNext（温度）；
大小++；
}
}
公共无效添加（T数据，整数位置）{
如果（位置>大小+1 | | | | |位置大小| |位置0）{
temp=temp.getNext（）；
}
返回温度；
}
私有类节点{
私有T数据；
私有节点下一步；
公共节点（）{
this.data=null；
next=null；
}
公共节点（T数据）{
这个数据=数据；
next=null；
}
公共T getData（）{
返回数据；
}
公共节点getNext（）{
下一步返回；
}
公共void setNext（节点next）{
this.next=next；
}
}
}

我看到的问题是您的

节点。getNext

调用返回的是

节点，而不是
节点。这相当于返回
节点
而不是泛型类型的方法

因此，你应该改变：

public Node getNext() {
    return next;
}

到

公共节点getNext（）{
下一步返回；
}
尽管斯博钦的回答会修正一些警告，但执行以下操作将修正所有警告：

用
T2
替换
节点
类中
T
的所有实例，包括类声明中的实例
将
getNext
的返回更改为
节点
将
setNext
中的参数类型更改为
Node
将
search
中的
temp
类型更改为
Node
您可能还希望将
@SuppressWarnings（“unused”）
添加到
公共节点（）
，因为这也会生成编译器警告
您可能还希望将
节点
类设置为静态类，因为它的任何方法都不依赖于它所在的
LinkedListGeneric
对象

或者，您可以完全从
节点
中删除type参数，这将删除除未使用的警告之外的所有警告。但是，你必须让你的课堂保持非静态。
你从哪里得到警告？你明白这个警告的意思吗？好吧，编译器告诉你它来自哪几行？一目了然？从
私有类节点
中删除
，它嵌套在一个已经定义了
T
的类型中，因此您只是在跟踪。“未检查或不安全”指的是您已经定义了
节点
，但正在调用
节点
（否
）。另外，您不应该使用相同的类型变量（使用
T2
或
节点的某些内容）来泛化
列表
和
节点
），谢谢大家的帮助。警告已消失。感谢您提出的“静态”或不使用节点类中的类型参数的建议。比我编写代码时想象的要好得多。
public Node<T> getNext() {
    return next;
}