Can someone explain basic Java Generics to me?

I have a problem set for my programming class which I'm working on. The problem set starts with:

Given the following definition of a linked list class:

1 public class Node<T> {
2 public T data;
3 public Node<T> next;
4 public Node(T data, Node<T> next) {
5     this.data = data; this.next = next;
6     }
7 }
8
9 public class LinkedList<T> {
10 priva开发者_开发知识库te Node<T> front; 
11 ...
12 }

Now, I can't quite figure out what "Node< T >" means (line 1)... I found some literature on wildcards (I.E. List), but this is still not making much sense to me. I was wondering if anyone could explain why wildcards are used (specifically, in this case), or, if this isn't an example of a wildcard, I was wondering if someone could tell me what it is? The book I have ("Data Structures Outside In: Java") doesn't mention anything helpful, neither does the oracle tutorial site I was on (link below, in case anyone wants to see what oracle had to say)

(I was on this website: http://download.oracle.com/javase/tutorial/extra/generics/wildcards.html but I'm still having trouble understanding what wildcards are used for, and figuring out if this is an example of a wildcard)

thank you for your help!

First, the Node represents a node of the linked list. With a singly-linked list each node holds a value and a reference to the next node in the list.

Then, the generics (T is generic type, not a wildcard) define that the type of value of each Node must be the same as the type defined for the List.

I'd recommend reading about java generics

The power of generics in java -- you can now use this linked list in this way:

LinkedList<Pizza> pizzaList = new LinkedList<Pizza>();
// ...

Node<Pizza> p = pizzaList.front;
while (p != null) {
  eat(p.data);
  p = p.next;
}

Basically the generics take care of casting for you, where you otherwise would have been writing (Pizza)p.data in your code.

Wildcards, technically generics, can be any object. T can be String, Comparable, JList. The advantage is that everything in the list is the same type, so everything that comes out will be the same.

For example, I can make a Node and when I access Node.data, it will be in a String form, which means that I don't have to cast: String data = (String)node.data;

To answer your wildcard piece of the question...

Wildcards are constraints against the generic type. There are three types of wildcards:

<?>

<? extends T> or <? extends IRunnable>

<? super T>

A wildcard puts a restraint on what can go into either the class or a specific method in the generic. <?> means that any object can be used in the generic class or wherever this constraint is defined. <? extends T> means that the class coming into the generic must inherit from T or implement the interface T. <? extends IRunnable> means that the class coming into the generic must implement the IRunnable interface at some point in its hierarchy. Finally, <? super T> means that the incoming class to the generic must be of a super type of T (i.e., a parent in the hierarchy of T).