Question

I finished learning Generics and I didn’t find it easy. However , I did understand it. Here is what I understood. I want you to correct me where I am wrong and answer a few questions 🙂 .

public class LinkedList<T> {
//class definition
}

This means that LinkedList<> is a class that will accept objects of classes and also interfaces.

public class LinkedList<T extends Object> {
//class definition
}

This means that LinkedList<> is a class that will accept objects of those classes only that extend Object class. Basically, all classes. In case of a raw type, T will be replaced by Object

public class LinkedList<T extends Object & java.lang.Serializable> {
//class definition
}  

This means that LinkedList<> is a class that accepts objects of all those classes that implement Serializable interface. If an object of user defined class has to be included in the list then the user defined class must implement Serializable.

public class LinkedList<T> implements Iterable<T> {
//class definition
}  

This means that the LinkedList<> class can be used with a collection-based for loop. It must overload iterator() method and should have an inner class that implements Itarator<T> and overloads hasNext(), next() and remove()

Questions
1. Please explain the meaning of this in simple words and with an example, if possible:
public class BinaryTree<T extends Comparable<? super T>> what replaces the ?
2. I want to write the above mentioned LinkedList<> class to a file using the writeObject() method. so I declare it as

public class LinkedList<T extends Object> implements Serializable {
     //methods and data members      
private class Node implements Serializable { //inner class
                  T object;
                  Node next;
           }
    }

Does the inner class have to implement Serializable as well?

Answer 1

About your four first points:

1. A list that is is supposed to contain instances of T (including classes that extend T).
2. Actually identical to the first one, as all classes extend Object.
3. A list that can only contain objects that are Serializable (same as class LinkedList<T extends Serializable> { ... })
4. An iterable list of T, so yeah, it can be used in enhanced loops.

Worth noting, when we say “a list that can only contain objects of the specified type”, we should say “should” instead of “can”. Unless you pass Class<?> objects around, Java (runtime) will not check the values passed in actually comply, only the compiler will, and only based on the visible static type, which could’ve been manually changed (that’d issue a warning).

About the questions:

1. It represents a BinaryTree that contains objects that are Comparable to any object of the same class as T or any of its supertypes (Object is one supertype of all classes, essentially all classes that T extends and all interfaces it implements).
2. If you want to serialize the object using writeObject, then all non-transient (i.e. that you cannot rebuild based on other data) instance fields of that object need to be Serializable as well, or writeObject will ignore them. Your code extract isn’t quite sufficient to tell whether Node needs to be Serializable or not, but it probably needs to given the general idea of the List example.