If you want to provide feedback or have any questions regarding Java generics, to which you cannot find an answer in this document, feel free to send me EMAIL or use the GENERICS FAQ form.
A printable version of the FAQ documents is available in PDF format (4.5MB).

Generic And Parameterized Types

Generic And Parameterized Types

Fundamentals

What is a parameterized or generic type?
 

A generic type is a type with formal type parameters. A parameterized type is an instantiation of a generic type with actual type arguments.
A generic type is a reference type that has one or more type parameters. These type parameters are later replaced by type arguments when the generic type is instantiated (or declared ).  Example (of a generic type):  interface Collection<E>  {    public void add (E x);    public Iterator<E> iterator(); } The interface Collection has one type parameter E .  The type parameter E is a place holder that will later be replaced by a type argument when the generic type is instantiated and used. The instantiation of a generic type with actual type arguments is called a parameterized type .  Example (of a parameterized type):  Collection<String> coll = new LinkedList<String>(); The declaration Collection<String> denotes a parameterized type, which is an instantiation of the generic type Collection ,  where the place holder E has been replaced by the concrete type String .
LINK TO THIS	GenericTypes.FAQ001
REFERENCES	What is a type parameter?

How do I define a generic type?
 

Like a regular type, but with a type parameter declaration attached.
A generic type is a reference type that has one or more type parameters. In the definition of the generic type, the type parameter section follows the type name. It is a comma separated list of identifiers and is delimited by angle brackets.  Example (of a generic type):  class Pair<X,Y>  {    private X first;   private Y second;   public Pair(X a1, Y a2) {     first  = a1;     second = a2;   }   public X getFirst()  { return first; }   public Y getSecond() { return second; }   public void setFirst(X arg)  { first = arg; }   public void setSecond(Y arg) { second = arg; } } The class Pair has two type parameters X and Y .  They are replaced by type arguments when the generic type Pair is instantiated. For instance, in the declaration Pair<String, Date> the type parameter X is replaced by the type argument String and Y is replaced by  Date .  The scope of the identifiers X and Y is the entire definition of the class.  In this scope the two type parameters X and Y are used like they were types (with some restrictions). In the example above, the type parameters are used as the argument and return type of instance methods and the types of instance fields.  Type parameters can be declared with bounds. Bounds give access to methods of the unknown type that the type parameter stands for. In our example, we do not invoke any methods of the unknown types X and Y . For this reason, the two type parameters are unbounded.
LINK TO THIS	GenericTypes.FAQ002
REFERENCES	What is a type parameter? What is a bounded type parameter? What is a type parameter bound?

Are there any types that cannot have type parameters?

How is a generic type instantiated?

Why do instantiations of a generic type share the same runtime type?

Can I cast to a parameterized type?

Can I use parameterized types in exception handling?

Can generic types have static members?

Concrete Instantiations

What is a concrete parameterized type?

Is List<Object> a supertype of List<String>?

Can I use a concrete parameterized type like any other type?

Can I create an array whose component type is a concrete parameterized type?
 

No, because it is not type-safe.
Arrays are covariant, which means that an array of supertype references is a supertype of an array of subtype references.  That is, Object[] is a supertype of String[] and a string array can be accessed through a reference variable of type Object[] .  Example (of covariant arrays):  Object[] objArr = new String[10];  // fine objArr[0] = new String(); In addition, arrays carry runtime type information about their component type, that is, about the type of the elements contained.  The runtime type information regarding the component type is used when elements are stored in an array in order to ensure that no "alien" elements can be inserted.  Example (of array store check):  Object[] objArr = new String[10]; objArr[0] = new Long(0L); // compiles; fails at runtime with ArrayStoreException The reference variable of type Object[] refers to a String[] , which means that only strings are permitted as elements of the array.  When an element is inserted into the array, the information about the array's component type is used to perform a type check - the so-called array store check. In our example the array store check will fail because we are trying to add a Long to an array of String s.  Failure of the array store check is reported by means of a ArrayStoreException .  Problems arise when an array holds elements whose type is a concrete parameterized type. Because of type erasure, parameterized types do not have exact runtime type information.  As a consequence, the array store check does not work because it uses the dynamic type information regarding the array's (non-exact) component type for the array store check.  Example (of array store check in case of parameterized component type):  Pair<Integer,Integer>[] intPairArr = new Pair<Integer,Integer>[10]; // illegal Object[] objArr = intPairArr;  objArr[0] = new Pair<String,String>("",""); // should fail, but would succeed If arrays of concrete parameterized types were allowed, then a reference variable of type Object[] could refer to a Pair<Integer,Integer>[] , as shown in the example. At runtime an array store check must be performed when an array element is added to the array. Since we are trying to add a Pair<String,String> to a Pair<Integer,Integer>[] we would expect that the type check fails. However, the JVM cannot detect any type mismatch here: at runtime, after type erasure, objArr would have the dynamic type Pair[] and the element to be stored has the matching dynamic type Pair . Hence the store check succeeds, although it should not.  If it were permitted to declare arrays that holds elements whose type is a concrete parameterized type we would end up in an unacceptable situation.  The array in our example would contain different types of pairs instead of pairs of the same type.  This is in contradiction to the expectation that arrays hold elements of the same type (or subtypes thereof).  This undesired situation would most likely  lead to program failure some time later, perhaps when a method is invoked on the array elements.  Example (of subsequent failure):  Pair<Integer,Integer>[] intPairArr = new Pair<Integer,Integer>[10]; // illegal Object[] objArr = intPairArr;  objArr[0] = new Pair<String,String>("",""); // should fail, but would succeed Integer i = intPairArr[0].getFirst(); // fails at runtime with ClassCastException The method getFirst is applied to the first element of the array and it returns a String instead of an Integer because the first element in the array intPairArr is a pair of strings, and not a pair of integers as one would expect. The innocent-looking assignment to the Integer variable i will fail with a ClassCastException , although no cast expression is present in the source code.  Such an unexpected ClassCastException is considered a violation of type-safety.  In order to prevent programs that are not type-safe all arrays holding elements whose type is a concrete parameterized type are illegal. For the same reason, arrays holding elements whose type is a wildcard parameterized type are banned, too.  Only arrays with an unbounded wildcard parameterized type as the component type are permitted.  More generally, reifiable types are permitted as component type of arrays, while arrays with a non-reifiable component type are illegal.
LINK TO THIS	GenericTypes.FAQ104
REFERENCES	What does type-safety mean? Can I declare a reference variable of an array type whose component type is a concrete parameterized type? Can I create an array whose component type is a wildcard parameterized type? Why is it allowed to create an array whose component type is an unbounded wildcard parameterized type? What is a reifiable type?

Can I declare a reference variable of an array type whose component type is a concrete parameterized type?
 

Yes, you can, but you should not, because it is neither helpful nor type-safe.
You can declare a reference variable of an array type whose component type is a concrete parameterized type. Arrays of such a type must not be created.  Hence, this reference variable cannot refer to an array of its type.  All that it can refer to is null , an array whose component type is a non-parameterized subtype of the concrete parameterized type, or an array whose component type is the corresponding raw type. Neither of these cases is overly useful, yet they are permitted.  Example (of an array reference variable with parameterized component type):  Pair<String,String>[] arr = null;  // fine arr = new Pair<String,String>[2] ; // error: generic array creation The code snippet shows that a reference variable of type Pair<String,String>[] can be declared, but the creation of such an array is rejected.  But we can have the reference variable of type Pair<String,String>[] refer to an array of a non-parameterized subtype.  Example (of another array reference variable with parameterized component type):  class Name extends Pair<String,String> { ... } Pair<String,String>[] arr = new Name[2] ;    // fine Which raises the question: how useful is such an array variable if it never refers to an array of its type?  Let us consider an example.  Example (of an array reference variable refering to array of subtypes; not recommended):  void printArrayOfStringPairs( Pair<String,String>[] pa) {   for (Pair<String,String> p : pa)     if (p != null)       System.out.println(p.getFirst()+" "+p.getSecond());  } Pair<String,String>[] createArrayOfStringPairs() {   Pair<String,String>[] arr = new Name[2];   arr[0] = new Name("Angelika","Langer");   // fine   arr[1] = new Pair<String,String>("a","b");  // fine (causes ArrayStoreException)   return arr; } void extractStringPairsFromArray( Pair<String,String>[] arr) {   Name name = (Name) arr[0]; // fine   Pair<String,String> p1 = arr[1];    // fine } void test() {   Pair<String,String>[] arr = createArrayOfStringPairs ();   printArrayOfStringPairs (arr);    extractStringPairsFromArray(arr); } The example shows that a reference variable of type Pair<String,String>[] can refer to an array of type Name[] , where Name is a non-parameterized subtype of Pair<String,String> .  However, using a reference variable of type Pair<String,String>[] offers no advantage over using a variable of the actual type Name[] .  Quite the converse; it is an invitation for making mistakes.  For instance, in the createArrayOfStringPairs method the compiler would permit code for insertion of elements of type Pair<String,String> into the array though the reference variable of type Pair<String,String>[] . Yet, at runtime, this insertion will always fail with an ArrayStoreException because we are trying to insert a Pair into a Name[] .  The same would happen if we tried to insert a raw type Pair into the array; it would compile with an "unchecked" warning and would fail at runtime with an ArrayStoreException .  If we used Name[] instead of Pair<String,String>[] the debatable insertions would not compile in the first place.  Also, remember that a variable of type Pair<String,String>[] can never refer to an array that contains elements of type Pair<String,String> .  When we want to recover the actual type of the array elements, which is the subtype Name in our example, we must cast down from Pair<String,String> to Name , as is demonstrated in the extractStringPairsFromArray method.  Here again, using a variable of type Name[] would be much clearer.  Example (improved):  void printArrayOfStringPairs( Pair<String,String>[] pa) {   for (Pair<String,String> p : pa)     if (p != null)       System.out.println(p.getFirst()+" "+p.getSecond());  } Name[] createArrayOfStringPairs() {   Name[] arr = new Name[2] ;   arr[0] = new Name("Angelika","Langer");   // fine   arr[1] = new Pair<String,String>("a","b");  // error   return arr; } void extractStringPairsFromArray( Name[] arr) {   Name name = arr[0];               // fine (needs no cast)   Pair<String,String> p1 = arr[1];    // fine } void test() {   Name[] arr = createArrayOfStringPairs ();   printArrayOfStringPairs (arr);   extractStringPairsFromArray(arr); } Since an array reference variable whose component type is a concrete parameterized type can never refer to an array of its type, such a reference variable does not really make sense.  Matters are even worse than in the example discussed above, when we try to have the variable refer to an array of the raw type instead of a subtype. First, it leads to numerous "unchecked" warnings because we are mixing use of raw and parameterized type.  Secondly, and more importantly, this approach is not type-safe and suffers from all the deficiencies that lead to the ban of arrays of concrete instantiation in the first place.  No matter how you put it, you should better refrain from using array reference variable whose component type is a concrete parameterized type.  Note, that the same holds for array reference variable whose component type is a wildcard parameterized type. Only array reference variable whose component type is an unbounded wildcard parameterized type make sense. This is because an unbounded wildcard parameterized type is a reifiable type and arrays with a reifiable component type can be created;  the array reference variable can refer to an array of its type and the deficiencies discussed above simply do not exist for unbounded wildcard arrays.
LINK TO THIS	GenericTypes.FAQ104A
REFERENCES	What does type-safety mean? Can I create an array whose component type is a concrete parameterized type? Can I declare a reference variable of an array type whose component type is a bounded wildcard parameterized type? Can I create an array whose component type is a wildcard parameterized type? Can I declare a reference variable of an array type whose component type is an unbounded wildcard parameterized type? Why is it allowed to create an array whose component type is an unbounded wildcard parameterized type? What is a reifiable type?

How can I work around the restriction that there are no arrays whose component type is a concrete parameterized type?

Why is there no class literal for concrete parameterized types?
 

Because parameterized type has no exact runtime type representation.
A class literal denotes a Class object that represents a given type. For instance, the class literal String.class denotes the Class object that represents the type String and is identical to the Class object that is returned when method getClass is invoked on a S tring object. A class literal can be used for runtime type checks and for reflection.  Parameterized types lose their type arguments when they are translated to byte code during compilation in a process called type erasure . As a side effect of type erasure, all  instantiations of a generic type share the same runtime representation, namely that of the corresponding raw type .  In other words, parameterized types do not have type representation of their own. Consequently, there is no point in forming class literals such as List<String>.class , List<Long>.class and List<?>.class , since no such Class objects exist.  Only the raw type List has a Class object that represents its runtime type. It is referred to as List.class .
LINK TO THIS	GenericTypes.FAQ106
REFERENCES	What is type erasure? What is the raw type?

 

Raw Types

What is the raw type?

Why are raw types permitted?

Can I use a raw type like any other type?

Wildcard Instantiations

What is a wildcard parameterized type?

What is the unbounded wildcard parameterized type?

What is the difference between the unbounded wildcard parameterized type and the raw type?

Which methods and fields are accessible/inaccessible through a reference variable of a wildcard parameterized type?

Can I use a wildcard parameterized type like any other type?
 

No.  A wildcard parameterized type is not a type in the regular sense (different from a non-parameterized class/interface or a raw type).
Wildcard parameterized types can be used for typing (like non-parameterized classes and interfaces):  as argument and return types of methods as type of a field or local reference variable  as component type of an array as type argument of other parameterized types as target type in casts  Wildcard parameterized type can NOT be used for the following purposes (different from non-parameterized classes and interfaces):  for creation of objects  for creation of arrays (except unbounded wildcard) in exception handling in instanceof expressions (except unbounded wildcard) as supertypes in a class literal
LINK TO THIS	GenericTypes.FAQ305
REFERENCES

Can I create an object whose type is a wildcard parameterized type?
 

No, not directly.
Objects of a wildcard parameterized type are not particularly useful, mainly because there is not much you can do with the object.  You can access an object of a wildcard parameterized type only through a reference of that wildcard parameterized type, and such a reference gives only restricted access to the referenced object.  Basically, the wildcard parameterized type is too abstract to be useful.  For this reason, the creation of objects of a wildcard parameterized type is discouraged: it is illegal that a wildcard parameterized type appears in a  new expression. Example (of illegal creation of objects of a wildcard parameterized type ):  ArrayList<String> list = new ArrayList<String>(); ... populate the list ... ArrayList<?> coll1 = new ArrayList <?> (); // error ArrayList<?> coll2 = new ArrayList <?> (10); // error ArrayList<?> coll3 = new ArrayList <?> (list); // error The compiler rejects all attempts to create an object of the wildcard type  ArrayList<?> . In a way, a wildcard parameterized type is like an interface type:  you can declare reference variables of the type, but you cannot create objects of the type.  A reference variable of an interface type or a wildcard parameterized type can refer to an object of a compatible type.  For an interface, the compatible types are the class (or enum) types that implement the interface.  For a wildcard parameterized type, the compatible types are the concrete instantiations of the corresponding generic type that belong to the family of instantiations that the wildcard denotes.  Example (comparing interface and wildcard parameterized type ):  Cloneable clon1 = new Date(); Cloneable clon2 = new Cloneable();     // error ArrayList<?> coll1 = new ArrayList <String> (); ArrayList<?> coll2 = new ArrayList <?> (); // error The code snippet above illustrates the similarity between an interface and a wildcard parameterized type, using the interface Cloneable and the wildcard parameterized type ArrayList<?> as examples.  We can declare reference variables of type Cloneable and ArrayList<?> , but we must not create objects of type Cloneable and ArrayList<?> . Interestingly, the compiler's effort to prevent the creation of objects of a wildcard parameterized type can be circumvented.  It is unlikely that you will ever want to create an object of a wildcard parameterized type, but should you ever need one, there's the workaround (see  TechnicalDetails.FAQ609 ).
LINK TO THIS	GenericTypes.FAQ306
REFERENCES	What is a wildcard parameterized type? Which methods and fields are accessible/inaccessible through a reference variable of a wildcard type? Can I use a wildcard instantiation like any other type? What is type argument inference? Is it really impossible to create an object whose type is a wildcard parameterized type?

Can I create an array whose component type is a wildcard parameterized type?
 

No, because it is not type-safe.
The rationale is the same as for concrete parameterized types: a wildcard parameterized type , unless it is an unbounded wildcard parameterized type , is a non-reifiable type and arrays of non-reifiable types are not type-safe.  The array store check cannot be performed reliably because a wildcard parameterized type that is not an unbounded wildcard parameterized type has a non-exact runtime type.  Example (of the consequences):  Object[] numPairArr = new Pair<? extends Number,? extends Number>[10]; // illegal numPairArr[0] = new Pair<Long,Long>(0L,0L);     // fine numPairArr[0] = new Pair<String,String>("",""); // should fail, but would succeed The array store check would have to check whether the pair added to the array is of type Pair<? extends Number,? extends Number> or of a subtype thereof. Obviously, a Pair<String,String> is not of a matching type and should be rejected with an ArrayStoreException .  But the array store check does not detect any type mismatch, because the JVM can only check the array's runtime component type, which is Pair[] after type erasure, against the element's runtime type, which is Pair after type erasure.
LINK TO THIS	GenericTypes.FAQ307
REFERENCES	What does type-safety mean? Can I create an array whose component type is a concrete parameterized type? Why is it allowed to create an array whose component type is an unbounded wildcard parameterized type? What is a reifiable type?

Can I declare a reference variable of an array type whose component type is a bounded wildcard parameterized type?
 

Yes, you can, but you should not, because it is neither helpful nor type-safe.
The rationale is the same as for concrete parameterized types: a wildcard parameterized type , unless it is an unbounded wildcard parameterized type , is a non-reifiable type and arrays of non-reifiable types must not be created.  Hence it does not make sense to have a reference variable of such an array type because it can never refer to array of its type.  All that it can refer to is null , an array whose component type is a non-parameterized subtype of the instantiations that belong to the type family denoted by the wildcard, or an array whose component type is the corresponding raw type. Neither of these cases is overly useful, yet they are permitted.  Example (of an array reference variable with wildcard parameterized component type):  Pair<? extends Number,? extends Number>[] arr = null;  // fine arr = new Pair<? extends Number,? extends Number>[2] ;  // error: generic array creation The code snippet shows that a reference variable of type Pair<? extends Number,? extends Number>[] can be declared, but the creation of such an array is illegal.  But we can have the reference variable of type Pair<? extends Number,? extends Number>[] refer to an array of a non-parameterized subtype of any of the concrete instantiations that belong to the type family denoted by Pair<? extends Number,? extends Number> . (Remember, wildcard parameterized types cannot be used as supertypes; hence a non-parameterized subtype must be a subtype of a concrete parameterized type .)  Example (of another array reference variable with parameterized component type):  class Point extends Pair<Double,Double> { ... } Pair<? extends Number,? extends Number>[] arr = new Point[2] ;    // fine Using a reference variable of type Pair<? extends Number,? extends Number>[] offers no advantage over using a variable of the actual type Point[] .  Quite the converse; it is an invitation for making mistakes.  Example (of an array reference variable refering to array of subtypes; not recommended):  Pair<? extends Number,? extends Number>[] arr = new Point[2]; arr[0] = new Point(-1.0,1.0);  // fine arr[1] = new Pair<Number,Number>(-1.0,1.0); // fine (causes ArrayStoreException) arr[2] = new Pair<Integer,Integer>(1,2); // fine (causes ArrayStoreException) The compiler  permits code for insertion of elements of type Pair< Number,Number > or Pair<Integer,Integer> into the array through the reference variable of type Pair<? extends Number,? extends Number>[] . Yet, at runtime, this insertion will always fail with an ArrayStoreException because we are trying to insert a Pair into a Point[] .   The debatable insertions would be flagged as errors and thereby prevented if we used the actual type of the array, namely Point[] instead of Pair<?extends Number,? extends Number>[] .  In essence, you should better refrain from using array reference variable whose component type is a wildcard parameterized type.  Note, that the same holds for array reference variable whose component type is a concrete parameterized type. Only an array reference variable whose component type is an unbounded wildcard parameterized type make sense. This is because an unbounded wildcard parameterized type is a reifiable type and arrays with a reifiable component type can be created;  the array reference variable can refer to an array of its type and the deficiencies discussed above simply do not exist for unbounded wildcard arrays.
LINK TO THIS	GenericTypes.FAQ307A
REFERENCES	What does type-safety mean? Can I create an array whose component type is a wildcard parameterized type? Can I declare a reference variable of an array type whose component type is a concrete parameterized type? Can I create an array whose component type is a concrete parameterized type? Can I declare a reference variable of an array type whose component type is an unbounded wildcard parameterized type? Why is it allowed to create an array whose component type is an unbounded wildcard parameterized type? What is a reifiable type?

Why is it allowed to create an array whose component type is an unbounded wildcard parameterized type?
 

Because it is type-safe.
The rationale is related to the rule for other instantiations of a generic type: an unbounded wildcard parameterized type is a reifiable type and arrays of reifiable types are type-safe, in contrast to arrays of non-reifiable types, which are not safe and therefore illegal. The problem with the unreliable array store check (the reason for banning arrays with a non-reifiable component type) does not occur if the component type is reifiable.  Example (of array of unbounded wildcard parameterized type ):  Object[] pairArr = new Pair<?,?>[10] ;        // fine pairArr[0] = new Pair <Long,Long>(0L,0L);     // fine pairArr[0] = new Pair <String,String>("",""); // fine  pairArr[0] = new ArrayList <String>();        // fails with ArrayStoreException The array store check must check whether the element  added to the array is of type Pair<?,?> or of a subtype thereof.  In the example the two pairs, although of different type, are perfectly acceptable array elements. And indeed, the array store check, based on the non-exact runtime type Pair , accepts the two pairs and correctly sorts out the "alien" ArrayList object as illegal by raising an ArrayStoreException . The behavior is exactly the same as for an array of the raw type, which is not at all surprising because the raw type is a reifiable type as well.
LINK TO THIS	GenericTypes.FAQ308
REFERENCES	What is a reifiable type? What does type-safety mean? What is the raw type? Can I create an array whose component type is a concrete parameterized type? Can I create an array whose component type is a wildcard parameterized type?

Can I declare a reference variable of an array type whose component type is an unbounded wildcard parameterized type?
 

Yes.
An array reference variable whose component type is an unbounded wildcard parameterized type (such as Pair<?,?>[] ) is permitted and useful.  This is in contrast to array reference variables with a component type that is a concrete or bounded wildcard parameterized type (such as Pair<Long,Long>[] or Pair<? extends Number,? extends Number>[] ); the array reference variable is permitted, but not overly helpful.  The difference stems from the fact that an unbounded wildcard parameterized type is a reifiable type and arrays with a reifiable component type can be created.  Concrete and bounded wildcard parameterized types are non -reifiable types and arrays with a non-reifiable component type can not be created.  As a result, an array variable with a reifiable component type can refer to array of its type, but this is not possible for the non-reifiable component types.  Example (of array reference variables with parameterized component types):  Pair<?,?>[] arr    = new Pair<?,?>[2] ;           // fine Pair<? extends Number,? extends Number>[] arr    = new Pair<? extends Number,? extends Number>[2] ;  // error: generic array creation Pair<Double,Double>[] arr    = new Pair<Double,Double>[2] ;    // error: generic array creation The examples above demonstrate that unbounded wildcard parameterized types are permitted as component type of an array, while other instantiations are not permitted.  In the case of a non-reifiable component type the array reference variable can be declared, but it cannot refer to an array of its type.  At most it can refer to an array of a non-parameterized subtype (or an array of the corresponding raw type), which opens opportunities for mistakes, but does not offer any advantage.
LINK TO THIS	GenericTypes.FAQ308A
REFERENCES	What is a reifiable type? Can I create an array whose component type is a wildcard parameterized type? Can I declare a reference variable of an array type whose component type is a concrete parameterized type? Can I create an array whose component type is a concrete parameterized type? Why is it allowed to create an array whose component type is an unbounded wildcard parameterized type? Can I declare a reference variable of an array type whose component type is a bounded wildcard parameterized type?

Can I derive from a wildcard parameterized type?
 

No, a  wildcard parameterized type is not a supertype.
Let us scrutinize an example and see why a wildcard parameterized type cannot be a supertype. Consider the generic interface Comparable .  Example (of a generic interface):  interface Comparable<T> {   int compareTo(T arg); } If it were allowed to subtype from a wildcard instantiation of Comparable , neither we nor the compiler would know what the signature of the compareTo method would be.  Example (of illegal use of a wildcard parameterized type as a supertype):  class MyClass implements Comparable <?> { // error   public int compareTo( ??? arg) { ... } } The signatures of methods of a wildcard parameterized type are undefined. We do not know what type of argument the compareTo method is supposed to accept. We can only subtype from concrete instantiations of the Comparable interface, so that the signature of the compareTo method is well-defined.  Example (of legal use of a concrete parameterized type as a supertype):  class MyClass implements Comparable <MyClass> {  // fine   public int compareTo( MyClass arg) { ... } } Note that the raw type is, of course, acceptable as a supertype, different from the wildcard parameterized types including the unbounded wildcard parameterized type .  Example (of legal use of a raw type as a supertype):  class MyClass implements Comparable {          // fine   public int compareTo( Object arg) { ... } }
LINK TO THIS	GenericTypes.FAQ309
REFERENCES	What is the raw type? What is a wildcard parameterized type? What is the unbounded wildcard parameterized type? What is the difference between the unbounded wildcard parameterized type and the raw type?

Why is there no class literal for wildcard parameterized types?
 

Because a wildcard parameterized type has no exact runtime type representation.
The rationale is the same as for concrete parameterized types.  Wildcard parameterized types lose their type arguments when they are translated to byte code in a process called type erasure . As a side effect of type erasure, all  instantiations of a generic type share the same runtime representation, namely that of the corresponding raw type .  In other words, parameterized types do not have type representation of their own. Consequently, there is no point to forming class literals such as List<?>.class , List<? extends Number>.class and List<Long>.class , since no such Class objects exist.  Only the raw type List has a Class object that represents its runtime type. It is referred to as List.class .
LINK TO THIS	GenericTypes.FAQ310
REFERENCES	What is type erasure? What is the raw type? Why is there no class literal for concrete parameterized types?

CONTENT PREVIOUS NEXT INDEX