Fundamentals of Java Generics

Examples of generic types can be found in the Collections framework of the J2SE 5.0 platform libraries. A class like LinkedList<E> is a generic type.  It has a type parameter E that represents the type of the elements stored in the list.  Instead of just using a LinkedList , not saying anything about the type of elements the list contains, we can use a LinkedList<String> or a LinkedList<Integer> , thereby specifying that we mean a list of strings or integral values respectively. 

Generic types are instantiated to form parameterized types by providing actual type arguments that replace the formal type parameters.  A class like LinkedList<E> is a generic type, that has a type parameter E . Instantiations, such as LinkedList<String> or a LinkedList<Integer> , are called parameterized types, and String and Integer are the respective actual type arguments.

In non-generic Java, homogenous collections of elements had required implementation of different classes, such as a class IntegerList and a class StringList for holding integral values and strings respectively. Naturally, implementing a separate collection class for  every conceivable element type is neither feasible nor desirable.  A more reasonable goal is to have a single implementation of the collection class and use it to hold elements of different types.  In other words, rather than implementing a class IntegerList and StringList , we want to have one generic implementation List that can be easily used in either case, as well as in other unforeseen cases. 

This is what generics are for: the implementation of one generic class can be instantiated for a variety of types.  There is one generic class List in the generic collections framework (see package java.util in Java 5.0).  It permits specification of List<Integer> , List<String> , etc. each of which is a homogenous collection of integral values, strings, etc.  In generic Java, the generic class List is a so-called generic class that has a type parameter.  Uses such as List<Integer> and List<String> are so-called parameterized types .  They are instantiations of the generic class, where the type parameter is replaced by the concrete type arguments Integer and String . 

The use of the Java generics language features were initially motivated by the need to have a mechanism for efficient implementation of homogenous collections, but the language feature is not restricted to collections. The J2SE 5.0 platform libraries contains numerous examples of generic types and methods that have nothing to do with collections.  Examples are the weak and soft references in package java.lang.ref , which are special purpose references to objects of a particular type represented by a type parameter.  Or the interface Callable in package java.util.concurrent , which represents a task and has a call method that returns a result of a particular type represented by a type parameter. Even class Class in package java.lang is a generic class since Java 5.0, whose type parameter denotes the type that the Class object represents.

Consider the example of a LinkedList<String> . The type LinkedList<String> expresses that the list is a homogenous list of elements of type String .  Based on the stronger information the compiler performs type checks in order to ensure that a LinkedList<String> contains only strings as elements. Any attempt to add an alien element is rejected with a compiler error message. 

Example (using a parameterized type): 

LinkedList<String> list = new LinkedList<String>();
list.add("abc");       // fine
list.add(new Date());  // error

Same example (using a non-parameterized type): 

LinkedList list = new LinkedList();
list.add("abc");       // fine
list.add(new Date());  // fine as well

Since it is ensured that a LinkedList<String> contains strings it is not necessary to cast an element retrieved from the list to type String . 

Example (using a parameterized type): 

LinkedList<String> list = new LinkedList<String>();
list.add("abc"); 
String s = list.get(0);  // no cast needed

Same example (using a non-parameterized type): 

LinkedList list = new LinkedList();
list.add("abc"); 
String s = (String)list.get(0);  // cast required