• What is a type parameter?
• What is a bounded type parameter?

• What is a type parameter bound?
• Which types are permitted as type parameter bounds?
• Can I use a type parameter as a type parameter bound?
• Can I use different instantiations of a same generic type as bounds of a type parameter?
• How can I work around the restriction that a type parameter cannot have different instantiations of a same generic type as its bounds?
• Does a bound that is a class type give access to all its public members?
• How do I decrypt " Enum<E extends Enum<E>> "?
• Why is there no lower bound for type parameters?

• Can I use a type parameter like a type?
• Can I create an object whose type is a type parameter?
• Can I create an array whose component type is a type parameter?
• Can I cast to the type that the type parameter stands for?
• Can I use a type parameter in exception handling?
• Can I derive from a type parameter?
• Why is there no class literal for a type parameter?

• Where is a type parameter visible (or invisible)?
• Can I use a type parameter as part of its own bounds?
• Can I use the type parameter of an outer type as part of the bounds of the type parameter of an inner type or a method?

• Is there one instances of a static field per instantiation of a generic type?
• Why can't I use a type parameter in any static context of a generic class?

Example of a parameterized type: 

interface Comparable<E>  { 
  int compareTo(E other);
}

Example (of a generic type without bounds): 

public class Hashtable<Key,Data> {
  ... 
  private static class Entry<Key,Data> {
    private Key key; 
    private Data value;
    private int hash;
    private Entry<Key,Data> next;
    ...
  }
  private Entry<Key,Data>[] table; 
  ... 
  public Data get(Key key) {
    int hash = key.hashCode() ;
    for (Entry<Key,Data> e = table[hash & hashMask]; e != null; e = e.next) {
      if ((e.hash == hash) && e. key.equals(key) ) {
        return e.value;
      }
    } 
    return null;
  }
}

Example (of a generic type, so far without bounds): 

public interface Comparable<T> {
  public int compareTo(T arg);
}
public class TreeMap<Key,Data>{
  private static class Entry<K,V> {
     K key;
     V value;
     Entry<K,V> left;
     Entry<K,V> right;
     Entry<K,V> parent;
  }
  private transient Entry<Key,Data> root;
  ...
  private Entry<Key,Data> getEntry(Key key) {
     Entry<Key,Data> p = root;
     Key k = key;
     while (p != null) {
       int cmp = k. compareTo(p.key) ; // error
       if (cmp == 0)
         return p;
       else if (cmp < 0)
         p = p.left;
       else 
         p = p.right; 
     }
     return null;
  }
  public boolean containsKey(Key key) {
     return getEntry(key) != null;
  }
  ...
}

In order to allow the invocation of the compareTo method we must tell the compiler that the unknown Key type has a compareTo method.  We can do so by saying that the Key type implements the Comparable<Key> interface.  We can say so by declaring the type parameter Key as a bounded parameter. 

Example (of the same generic type, this time with bounds): 

public interface Comparable<T> {
  public int compareTo(T arg);
}
public class TreeMap<Key extends Comparable<Key> ,Data>{
  private static class Entry<K,V> {
     K key;
     V value;
     Entry<K,V> left = null;
     Entry<K,V> right = null;
     Entry<K,V> parent;
  }
  private transient Entry<Key,Data> root = null;
  ...
  private Entry<Key,Data> getEntry(Key key) {
     Entry<Key,Data> p = root;
     Key k = key;
     while (p != null) {
       int cmp = k. compareTo(p.key) ; 
       if (cmp == 0)
         return p;
       else if (cmp < 0)
         p = p.left;
       else 
         p = p.right; 
     }
     return null;
  }
  public boolean containsKey(Key key) {
     return getEntry(key) != null;
  }
  ...
}

• It gives access to the methods that the bound specifies .  In the example, the bound Comparable<Key> gives access to the compareTo method that we want to invoke in the implementation of our TreeMap class.

• Only types "within bounds" can be used for instantiation of the generic type.   In the example, a parameterized type such as TreeMap<Number,String> would be rejected, because the type Number is not a subtype of Comparable<Number> .  A parameterized type like TreeMap<String,String> would be accepted, because the type String is within bounds, i.e. is a subtype of Comparable<String> .

Note that the suggested bound Comparable<Key> in this example is not the best conceivable solution.  A better bound, that is more relaxed and allows a larger set of type arguments, would be Comparable<? super Key> .  A more detailed discussion can be found in a separate FAQ entry (click here ).

Alternatively can have one or several bounds.  In this case the type argument that replaces the bounded type parameter in an instantiation of a generic type must be a subtype of all bounds. 

The syntax for specification of type parameter bounds is: 

<TypeParameter extends Class & Interface ₁ & ... & Interface _N >

Example (of type parameters with several bounds): 

class Pair<A extends Comparable<A> & Cloneable , 
           B extends Comparable<B> & Cloneable > 
  implements Comparable<Pair<A,B>>, Cloneable { ... }

Examples (of type parameter bounds): 

class X0 <T extends int > { ... }      // error
class X1 <T extends Object[] > { ... } // error
class X2 <T extends Number > { ... }
class X3 <T extends String > { ... }
class X4 <T extends Runnable > { ... }
class X5 <T extends Thread.State > { ... }
class X6 <T extends List > { ... }
class X7 <T extends List<String> > { ... }
class X8 <T extends List<? extends Number> > { ... }
class X9 <T extends Comparable<? super Number> > { ... }
class X10<T extends Map.Entry<?,?> > { ... }

Class types, such as Number or String , and interface types, such as Runnable , are permitted as type parameter bound. 

Enum types, such as Thread.State are also permitted as type parameter  bound. Thread.State is an example of a nested type used as type parameter bound.  Non-static inner types are also permitted. 

Raw types are permitted as type parameter bound; List is an example. 

Parameterized types are permitted as type parameter bound, including concrete parameterized types such as List<String> ,  bounded wildcard parameterized types such as List<? extends Number> and Comparable<? super Long> , and unbounded wildcard parameterized types such as Map.Entry<?,?> .  A bound that is a wildcard parameterized type allows as type argument all types that belong to the type family that the wildcard denotes.  The wildcard parameterized type bound gives only restricted access to fields and methods; the restrictions depend on the kind of wildcard. 

Example (of wildcard parameterized type as type parameter bound): 

class X< T extends List<? extends Number> > {
  public void someMethod(T t) {
    t.add(new Long(0L));    // error
    Number n = t.remove(0);
  }
}
class Test {
  public static void main(String[] args) {
     X<ArrayList< Long >>   x1 = new X<ArrayList<Long>>(); 
     X<ArrayList< String >> x2 = new X<ArrayList<String>>(); // error
  }
}

Note, that even types that do not have subtypes, such as final classes and enum types, can be used as upper bound.  In this case there is only one type that can be used as type argument, namely the type parameter bound itself. Basically, the parameterization is pointless then. 

Example (of nonsensical parameterization): 

class Box< T extends String > {
  private T theObject;
  public Box( T t) { theObject = t; }
  ...
}
class Test {
  public static void main(String[] args) {
    Box< String > box1 = Box<String>("Jack");
    Box< Long >   box2 = Box<Long>(100L);    // error
  }
}

Example (of a type parameter used as a type parameter bound): 

class Triple <T> {
  private T fst, snd, trd;
  public < U extends T , V extends T , W extends T > Triple(U arg1, V arg2, W arg3) {
    fst = arg1;
    snd = arg2;
    trd = arg3;
  }
}

Further opportunities for using type parameters as bounds of other type parameters include situations where a nested type is defined inside a generic type or a local class is defined inside a generic method.  It is even permitted to use a type parameter as bound of another type parameter in the same type parameter section.

Example (of a class used as bound of a type parameter): 

public class SuperClass {

    // static members
    public enum EnumType {THIS, THAT}
    public static Object staticField;
    public static void staticMethod() { ... }

    // non-static members
    public class InnerClass { ... }
    public Object nonStaticField;
    public void nonStaticMethod() { ... }

    // constructors
    public SuperClass() { ... }

    // private members
    private Object privateField; 

    ...
}

public final class SomeClass<T extends SuperClass > {
    private T object;
    public SomeClass(T t) { object = t; } 

    public String toString() {
        return
         "static nested type    : "+T.EnumType.class+"\n" 
        +"static field          : "+T.staticField+"\n"
        +"static method         : "+T.staticMethod()+"\n"
        +"non-static nested type: "+T.InnerClass.class+"\n"
        +"non-static field      : "+object.nonStaticField+"\n"
        +"non-static method     : "+object.nonStaticMethod()+"\n"
        +"constructor           : "+(new T())+"\n"                    // error
        +"private member        : "+object.privateField+"\n"          // error 
        ;
    }
}

Although a superclass bound gives access to types, fields and methods of the type parameter, only the non-static methods are dynamically dispatched. In the unlikely case that a subclass redefines types, fields and static methods of its superclass, these redefinitions would not be accessible through the superclass bound. 

Example (of a subclass of the bound used for instantiation): 

public final class SubClass extends SuperClass {

    // static members
    public enum Type {FIX, FOXI} 
    public static Object staticField;
    public static Object staticMethod() { ... }

    // non-static members 
    public class Inner { ... }
    public Object nonStaticField;
    public Object nonStaticMethod() { ... }

    // constructors 
    public SubClass(Object o) { ... }
    public SubClass(String s) { ... }

    ...
}

---

SomeClass< SubClass > ref = new SomeClass<SubClass>(new SubClass("xxx"));
System.out.println(ref);

---

prints:
static nested type    : SuperClass .EnumType
static field          : SuperClass .staticField
static method         : SuperClass .staticMethod  => SuperClass.staticField
non-static nested type: SuperClass .InnerClass
non-static field      : SuperClass .nonStaticField
non-static method     : SubClass .nonStaticMethod => SubClass.nonStaticField

public abstract class Enum<E extends Enum<E>> {
  ...
}

Here is a sketch of class Enum : 

public abstract class Enum< E extends Enum<E>> implements Comparable< E >, Serializable {
  private final String name;
  public  final String name() { ... }

  private final int ordinal;
  public  final int ordinal() { ... }

  protected Enum(String name, int ordinal) { ... }

  public String           toString() { ... }
  public final boolean    equals(Object other) { ... }
  public final int        hashCode() { ... }
  protected final Object  clone() throws CloneNotSupportedException { ... }
  public final int        compareTo( E o) { ... }

  public final Class< E > getDeclaringClass() { ... }
  public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) { ... }
}

Here is the contrived enum type Color : 

enum Color {RED, BLUE, GREEN}

public final class Color extends Enum<Color> {
  public static final Color[] values() { return (Color[])$VALUES.clone(); }
  public static Color valueOf(String name) { ... }

  private Color(String s, int i) { super(s, i); }

  public static final Color RED;
  public static final Color BLUE;
  public static final Color GREEN;

  private static final Color $VALUES[];

  static {
    RED = new Color("RED", 0);
    BLUE = new Color("BLUE", 1);
    GREEN = new Color("GREEN", 2);
    $VALUES = (new Color[] { RED, BLUE, GREEN });
  }
}

If we dissect the declaration " Enum<E extends Enum<E>> " we can see that this pattern has several aspects. 

First, there is the fact that the type parameter bound is the type itself: " Enum <E extends Enum <E>> ". It makes sure that only subtypes of type Enum are permitted as type arguments. (Theoretically, type Enum could be instantiated on itself, like in Enum<Enum> , but this is certainly not intended and it is hard to imagine a situation in which such an instantiation would be useful.)

Second, there is the fact that the type parameter bound is the parameterized type Enum <E> ,  which uses the type parameter E as the type argument of the bound. This declaration makes sure that the inheritance relationship between a subtype and an instantiation of Enum is of the form " X extends Enum<X> ". A subtype such as " X extends Enum<Y> " cannot be declared because the type argument Y would not be within bounds; only subtypes of Enum<X> are within bounds.

Third, there is the fact that Enum is generic in the first place.  It means that some of the methods of class Enum take an argument or return a value of an unknown type (or otherwise depend on an unknown type). As we already know, this unknown type will later be a subtype X of Enum<X> .  Hence, in the parameterized type Enum<X> , these methods involve the subtype X , and they are inherited into the subtype X .  The compareTo method is an example of such a method; it is inherited from the superclass into each subclass and has a subclass specific signature in each case. 

To sum it up, the declaration " Enum<E extends Enum<E>> " can be decyphered as: Enum is a generic type that can only be instantiated for its subtypes, and those subtypes will inherit some useful methods, some of which take subtype specific arguments (or otherwise depend on the subtype). 
 

Type parameters can have several bounds, like in class Box<T extends Number> {...} . But a type parameter can have no lower bound, that is, a construct such as class Box<T super Number> {...} is not permitted.  Why not?  The answer is: it is pointless because it would not buy you anything, were it allowed.  Let us see why lower bound type parameters of classes are confusing by exploring what a upper bound on a type parameter means. 

The upper bound on a type parameter has three effects: 

1. Restricted Instantiation. The upper bound restricts the set of types that can be used for instantiation of the generic type.  If we declare a class Box<T extends Number> {...} then the compiler would ensure that only subtypes of Number can be used as type argument.  That is, a Box<Number> or a Box<Long> is permitted, but a Box<Object> or Box<String> would be rejected.

 

 
 
 
 
 

Example (of restricted instantiation due to an upper bound on a type parameter): 
 

class Box<T extends Number> { 
   private T value; 
   public Box(T t) { value = t; } 
   ...
} 
class Test { 
   public static void main(String[] args) { 
       Box<Long>    boxOfLong   = new Box<Long>(0L);   // fine
       Box<String>  boxOfString = new Box<String>(""); // error: String is not within bounds
   }
}
2. Access To Non-Static Members. The upper bound gives access to all public non-static methods and fields of the upper bound.  In the implementation of our class Box<T extends Number> {...} we can invoke all public non-static methods defined in class Number , such as intValue() for instance.  Without the upper bound the compiler would reject any such invocation.Example (of access to non-static members due to an upper bound on a type parameter): 

class Box<T extends Number> { 
   private T value; 
   public Box(T t) { value = t; } 
   public int increment() { return value.intValue()+1; } // <= would be an error without the Number bound
   ...
} 
1. Type Erasure. The leftmost upper bound is used for type erasure and replaces the type parameter in the byte code.  In our class Box<T extends Number> {...} all occurrences of T would be replaced by the upper bound Number .  For instance, if class Box has a private field of type T and a method void set(T content) for setting this private field, then the field would be of type Number after type erasure and the method would be translated to a method void set(Number content) . 

 

 
 
 
 
 

Example (of use of upper bound on a type parameter in type erasure - before type erasure): 
 

class Box< T extends Number > { 
   private T value; 
   public Box( T t) { value = t; } 
   ...
} 
Example (of use of upper bound on a type parameter in type erasure - after type erasure): 
 
class Box { 
   private Number value; 
   public Box( Number t) { value = t; } 
   ...
}
In addition, the leftmost upper bound appears in further locations, such as automatically inserted casts and bridge methods.

If lower bounds were permitted on type parameters, which side effects would or should they have? If a construct such as class Box<T super Number> {...} were permitted, what would it mean?  What would the 3 side effects of an upper type parameter bound  - restricted instantiation, access to non-static member, type erasure - mean for a lower bound? 

Restricted Instantiations. The compiler could restrict the set of types that can be used for instantiation of the generic type with a lower bound type parameter.  For instance, the compiler could permit instantiations such as Box<Number> and Box<Object> from a Box<T super Number> and reject instantiations such as Box<Long> or Box<Short> .  This would be an effect in line with the restrictive side-effect described for upper type parameter bounds. 

Access To Non-Static Members. A lower type parameter bound does not give access to any particular methods beyond those inherited from class Object . In the example of Box<T super Number> the supertypes of Number have nothing in common, except that they are reference types and therefore subtypes of Object .  The compiler cannot assume that the field of type T is of type Number or a subtype thereof.  Instead, the field of type T can be of any supertype of Number , such as Serializable or Object .  The invocation of a method such as intValue() is no longer type-safe and the compiler would have to reject it. As a consequence, the lower type parameter bound would not give access to an non-static members beyond those defined in class Object and thus has the same effect as "no bound". 

Type Erasure .  Following this line of logic, it does not make sense to replace the occurences of the type parameter by its leftmost lower bound.  Declaring a method like the constructor Box( T t) as a constructor Box( Number t) does not make sense, considering that T is replaces by a supertype of Number .  An Object might be rightly passed to the constructor in an instantiation Box<Object> and the constructor would reject it.  This would be dead wrong.   So, type erasure would replace all occurences of the type variable T by type Object , and not by its lower bound.  Again, the lower bound would have the same effect as "no bound". 

Do you want to figure out what it would mean if both lower _and_ upper bounds were permitted?   Personally, I do not even want to think about it and  would prefer to file it under "not manageable", if you permit. 

The bottom line is:  all that a " super " bound would buy you is the restriction that only supertypes of Number can be used as type arguments.  And even that is frequently misunderstood.  It would NOT mean, that class Box<T super Number> {...} contains only instances of supertypes of Number .  Quite the converse - as the example below demonstrates! 

Example (of use of upper bound on a type parameter in type erasure - before type erasure): 

Lower Bound Type Parameters of Methods

In conjunction with methods and their argument types, a type parameter with a lower bound can occasionally be useful.

Example (of a method that would profit from a type parameter with a lower bound):

class Pair<X,Y> {
   private X first;
   private Y second;
   ...
   public < A super X , B super Y > B addToMap(Map<A,B> map) {  // error: type parameter cannot have lower bound
      return map.put(first, second);
   }
}
class Test { 
   public static void main(String[] args) { 
     Pair<String,Long> pair = new Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Number number = pair.addToMap(map);
   }
}

Since the compiler does not permit lower bounds on type parameters we need a work-around. 

One work-around that comes to mind is use of a wildcard, because wildcards can have a lower bound.  Here is a work-around using a wildcard.

Example (of a work-around for the previous example using wildcards):

class Pair<X,Y> {
   private X first;
   private Y second;
   ...
   public Object addToMap(Map< ? super X , ? super Y > map) { 
      return map.put(first, second);
   }
}
class Test { 
   public static void main(String[] args) { 
     Pair<String,Long> pair = new Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Number number = (Number) pair.addToMap(map);
   }
}

Another work-around is use of static methods.  Here is a work-around with a static instead of a non-static method.

Example (of a work-around for the previous example using a static method):

class Pair<X,Y> {
   private X first;
   private Y second;
   ...
   public static < A , B ,X extends A ,Y extends B > B addToMap(Pair<X,Y> pair, Map< A , B > map) {
      return map.put(pair.first,pair.second);
   }
}
class Test { 
   public static void main(String[] args) { 
     Pair<String,Long> pair = new Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Number number = Pair .addToMap( pair ,map);
   }
}

• as argument and return types of methods
• as type of a field or local reference variable 
• as type argument of other parameterized types
• as target type in casts 
• as explicit type argument of parameterized methods

• for creation of objects 
• for creation of arrays 
• in exception handling
• in static context
• in instanceof expressions 
• as supertypes
• in a class literal

Example (illegal generic object creation): 

public final class Pair< A , B > { 
    public final A fst;
    public final B snd;

    public Pair() {
       this.fst = new A() ;  // error
       this.snd = new B() ;  // error
    }
    public Pair(A fst, B snd) {
       this.fst = fst;
       this.snd = snd;
    }
}

In situations like this - when the compiler needs more knowledge about the unknown type in order to invoke a method - we use type parameter bounds. However, the bounds only give access to methods of the type parameter. Constructors cannot be made available through a type parameter bound. 

If you need to create objects of unknown type, you can use reflection as a workaround.  It requires that you supply type information, typically in form of a Class object, and then use that type information to create objects via reflection. 

Example (workaround using reflection): 

public final class Pair <A,B> { 
    public final A fst;
    public final B snd;

    public Pair( Class<A> typeA, Class<B> typeB) {
       this.fst = typeA. newInstance();
       this.snd = typeB. newInstance();
    }
    public Pair(A fst, B snd) {
       this.fst = fst;
       this.snd = snd;
    }
}

Example (before type erasure): 

class Sequence <T> {
  ... 
  public T[] asArray() {
    T[] array = new T[size] ; // error
    ...
    return array;
  }
}

class Sequence {
  ... 
  public Object [] asArray() {
    Object [] array = new Object [size];
    ...
    return array;
  }
}

Example (invocation of illegal method): 

S equence<String> seq = new Sequence<String>();
...
String[] arr = seq.asArray();            // compile-time error
String[] arr = (String[])seq.asArray();  // runtime failure: ClassCastException

If you need to create arrays of an unknown component type, you can use reflection as a workaround.  It requires that you supply type information, typically in form of a Class object, and then use that type information to create arrays via reflection. 

Example (workaround using reflection): 

class Sequence <T> {
  ... 
  public T[] asArray( Class<T> type) {
    T[] array = (T[])Array. newInstance(type,size) ; // unchecked cast
    ...
    return array;
  }
}

Example (of unchecked cast): 

class Twins<T> {
  public T fst,snd;
  public Twins(T s, T t) { fst = s; snd = t; }
  ...
}
class Pair<S,T> {
  private S fst;
  private T snd;
  public Pair(S s, T t) { fst = s; snd = t; }
  ... 
  public <U> Pair(Twins<U> twins) {
    fst = (S) twins.fst;        // unchecked warning
    snd = (T) twins.snd;        // unchecked warning
  }
}

Example (of illegal derivation from type parameter; before type erasure): 

class Printable<T extends Collection<?>> extends T {    // illegal
  public void printElements(PrintStream out) { 
    for (Object o : this)  out.println(o);
  }
  public void printElementsInReverseOrder(PrintStream out) { 
    ... 
  }
}
final class Test {
  public static void main(String[] args) {
    Printable<LinkedList<String>> list = new Printable<LinkedList<String>>();
    list.add(2,"abc");
    list.printElements(System.out);
  }
}

Example (same example after a conceivable translation by type erasure): 

class Printable extends Collection {    // error: Collection is an interface, not class
  public void printElements( PrintStream out) { 
    for (Object o : this)  out.println(o);
  }
  public void printElementsInReverseOrder( PrintStream out) {
    ... 
  }
}

final class Test {
  public static void main(String[] args) {
    Printable list = new Printable();
    list.add(2,"abc");                   // error: no such method can be found in class Printable
    list.printElements(System.out);
  }
}

The scope of a class's type parameter is the entire definition of the class, except any static members or static initializers of the class. This means that the type parameters cannot be used in the declaration of static fields or methods or in static nested types or static initializers. 

Example (of illegal use of type parameter in static context of a generic class): 

class SomeClass <T> {
  // static initializer, static field, static method
  static {
    SomeClass< T > test = new SomeClass< T >(); // error
  }
  private static T globalInfo;          // error
  public  static T getGlobalInfo() {        // error
    return globalInfo;
  }
  // non-static initializer, non-static field, non-static method
  { 
    SomeClass< T > test = new SomeClass< T >();
  }
  private        T localInfo;
  public         T getLocalInfo() { 
    return localInfo;
  }
  // static nested types
  public static class Failure extends Exception {
    private final T info;          // error
    public Failure( T t) { info = t; }      // error
    public T getInfo() { return info; }    // error
   }
  private interface Copyable {
    T copy();                      // error
  }
  private enum State {
    VALID, INVALID;
    private T info; // error
    public void setInfo( T t) { info = t; } // error
    public T getInfo() { return info; }    // error
  }
  // non-static nested types
  public class Accessor {
    public T getInfo() { return localInfo; }
  }
}

Generic Interfaces

The scope of an interface's type parameter is the entire definition of the interface, except any fields or nested types.  This is because fields and nested types defined in an interface are implicitly static. 

Example (of illegal use of type parameter in a generic interface): 

interface SomeInterface <T> {
  // field
  SomeClass< T > value = new SomeClass< T >();  // error
  // nested type
  class Accessor {
    public T getInfo() {            // error
      return value.getGlobalInfo();
    }
  }
  // methods
  T getValue();
}

Generic Methods

The scope of a method's or constructor's type parameter is the entire definition of the method; there is no exception, because a method has no static parts. 

Example (of use of type parameter in a generic method): 

private interface Copyable<T> {
  T copy();
}
// non-static method
<T extends Copyable<T>> void nonStaticMethod( T t) {
   final T copy = t.copy();

   class Task implements Runnable {
     public void run() {
       T tmp = copy;
       System.out.println(tmp);
     }
   }
   (new Task()).run();
}
// static method
static <T extends Copyable<T>> void staticMethod( T t) {
  final T copy = t.copy();

  class Task implements Runnable {
    public void run() {
       T tmp = copy;
       System.out.println(tmp);
    }
  } 
  (new Task()).run();
}

Example (of use of a type parameter in the type parameter section itself): 

public final class Wrapper < T extends Comparable < T >> implements Comparable<Wrapper<T>> {
  private final T theObject;
  public Wrapper(T t) { theObject = t; }
  public T getWrapper() { return theObject; }
  public int compareTo(Wrapper<T> other) { 
    return theObject.compareTo(other.theObject); 
  }
}

Example (of use of a type parameter in the type parameter section itself): 

< S ,T extends S > T create(S arg) { ... }

Forward references to type parameters are not permitted.  The type parameter cannot be used in the entire type parameter section, but only after its point of declaration. 

Example (of an illegal forward reference to a type parameter): 

< S extends T , T extends Comparable< S >> T create(S arg) { ... }  // error

Forward references to types, not type parameters, are permitted, though. 

Example (of an forward reference to a type): 

interface Edge <N extends Node <? extends Edge<N>>> {
  N getBeginNode();
  void setBeginNode(N n);
  N getEndNode();
  void setEndNode(N n);
}
interface Node <E extends Edge <? extends Node<E>>> {
  E getOutEdge();
  void setOutEdge(E e);
  E getInEdge();
  void setInEdge(E e);
}

Example (of a generic class with a static field): 

class SomeClass<T> {
  public static int count;
  ...
}

Example (of several instantiations and usage of the static field(s)): 

SomeClass<String> ref1 = new SomeClass<String>();
SomeClass<Long>   ref2 = new SomeClass<Long>();

ref1.count++; 
ref2.count++; 

The reason is that the compiler translates the definition of a generic type into one unique byte code representation of that type.  The different instantiations of the generic type are later mapped to this unique representation by means of type erasure . The consequence is that there is only one static count field in our example, despite of the fact that we can work with as many instantiations of the generic class as we like. 

Example (showing the syntax for access to a static field of a generic type): 

SomeClass<String> ref1 = new SomeClass<String>();
SomeClass<Long>   ref2 = new SomeClass<Long>();

ref1.count++;               // discouraged, but legal
ref2.coun t++;               // discouraged, but legal
SomeClass .count++; // fine, recommended
SomeClass<String>.count++;  // error
SomeClass<Long>.count++;    // error