与 Generics 不兼容的类型

Question

I am unfamiliar with generics, so in this method here where i'm trying to implement a remove method from scratch, :

public class LinkedList<T> implements LinkedListInterface<T> {
    private Node head;
    private Node tail;
    private int count;
    public LinkedList () {
        head = null;
        tail = null;
        count = 0;
    }
    class Node {
        T data;
        Node next;
        
        Node(T data) {
            this.data = data;
            next = null;
        }
    }
    public Node getHead() {
        return head;
    }

    public T remove(int pos) throws ListException {
      if (pos < 1 || pos > count) {
        throw new ListException("Invalid position to remove from");
      }
      Node removedItem = null;
      if (count == 1) {
        removedItem = head;
        head = null;
        tail = null;
      }
      else if (pos == 1) {
        removedItem = head;
        head = head.next;
      }
      else if (pos == count) {
        removedItem = tail;
        Node prev = jump(pos - 2);
        prev.next = null;
        tail = prev;
      }
      else {
        Node prev = jump(pos - 2);
        removedItem = prev.next;
        prev.next = prev.next.next;
      }
      count--;
      return removedItem; // error: incompatible types: LinkedList<T>.Node cannot be converted to T
    }
}

I need help identifying what this 'T' is exactly in the remove method and what this error message means and what I should do to fix it, thanks for the help

Answer 1

Generics (or rather, the proper name, 'type variables') is a way to link things .

All Ts represent a type. Everyplace T is mentioned, it's the same type for any given 'usage' of a thing, but you don't know what T is. It could be Number, it could String, it could SomethingYouNeverHeardAbout. But it's some type or other. If you did know, you'd just write that out instead.

In your snippet, public LinkedList<T> declares the type variable (just like you need to type int x; before you can start using x as a variable that can hold values , you need to declare a type variable , and that's where it is declared. T has no restrictions - it can be any type (except primitives, because primitive types and generics don't mix at all, at least, for now - maybe future java versions change this).

All other occurrences of T in the entire file are simply usages of it.

In other words, your code says: For any specific LinkedList, it has some type associated with it. We have no idea what it is, but every instance has such a thing.

Generics are entirely a compile time affair so this has no effect whatsoever when you run the code, it's solely for the compiler to help you out and tie things together. The point of the exercise is simply to let you tell the compiler that various types used in different places are unknown, but we do know, they are the same.

So, given any particular instance of LinkedList, its remove method returns the same type that its add method receives. Which is the same type as the data field of its internal Node inner class.

What does this get you? Compile-time checking, for one. The compiler can now find bugs for you. And so it has! Your intent is clearly for the remove method to return the thing it removed, but you aren't doing that. You are actually returning the node object that contains the thing you removed. This node object isn't even publicly visible (your Node internal class has package private access), clearly completely useless to return that, and as per your signature, you didn't mean to.

To fix your bug, just write return removedItem.data; instead.