?
is a special kind of type argument that controls the Covariance for generic types
Unlike arrays (which are covariant in Java), different instantiations of a generic type are not compatible with each other, not even explicitly: With the declarationGeneric superGeneric; Generic subGeneric;
the compiler would report a conversion error for both castings (Generic)superGeneric
and (Generic)subGeneric
.
This incompatibility may be softened by the wildcard if ?
is used as an actual type parameter: Generic>
is a supertype of all parameterizarions of the generic type Generic
. This allows objects of type Generic
and Generic
to be safely assigned to a variable or method parameter of type Generic>
. Using Generic extends Supertype>
allows the same, restricting compatibility to Supertype
and its children. Another possibility is Generic super Subtype>
, which also accepts both objects and restricts compatibility to Subtype
and all its parents.
Wildcard as parameter type
In the body of a generic unit, the (formal) type parameter is handled like itsextends
; Object
if not constrained). If the return type of a method is the type parameter, the result (e.g. of type ?
) can be referenced by a variable of the type of the upper bound (or Object
). In the other direction, the wildcard fits no other type, not even Object
: If ?
has been applied as the formal type parameter of a method, no actual parameters can be passed to it. However, objects of the unknown type can be read from the generic object and assigned to a variable of a supertype of the upperbound.
Bounded wildcards
A bounded wildcard is one with either an upper or a lowerUpper bounds
An upper bound on a wildcard must be a subtype of the upper bound of the corresponding type parameter declared in the corresponding generic type. An example of a wildcard that explicitly states an upper bound is:Generic extends SubtypeOfUpperBound> referenceConstrainedFromAbove;
This reference can hold any parameterization of Generic
whose type argument is a subtype of SubtypeOfUpperBound
. A wildcard that does not explicitly state an upper bound is effectively the same as one that has the constraint extends Object
, since all reference types in Java are subtypes of Object.
Lower bounds
A wildcard with a lower bound, such asGeneric super SubtypeOfUpperBound> referenceConstrainedFromBelow;
can hold any parameterization of Generic
whose any type argument is both a subtype of the corresponding type parameter's upper bound and a supertype of SubtypeOfUpperBound
.
Object creation with wildcard
No objects may be created with a wildcard type argument: for example,new Generic>()
is forbidden. In practice, this is unnecessary because if one wanted to create an object that was assignable to a variable of type Generic>
, one could simply use any arbitrary type (that falls within the constraints of the wildcard, if any) as the type argument.
However, new ArrayList>()
is allowed, because the wildcard is not a parameter to the instantiated type ArrayList
. The same holds for new ArrayList>()
.
In an array creation expression, the component type of the array must be reifiable as defined by the Java Language Specification, Section 4.7. This entails that, if the component type of the array has any type arguments, they must all be unbounded wildcards (wildcards consisting of only a ?
) . For example, new Generic> 0/code> is correct, while new Generic 0/code> is not.
For both cases, using no parameters is another option. This will generate a warning since it is less type-safe (see Raw type
Generics are a facility of generic programming that were added to the Java programming language in 2004 within version J2SE 5.0. They were designed to extend Java's type system to allow "a type or method to operate on objects of various types while ...
).
Example: Lists
In the Java Collections Framework, the class List
represents an ordered collection of objects of type MyClass
.
Upper bounds are specified using extends
:
A List extends MyClass>
is a list of objects of some subclass of MyClass
, i.e. any object in the list is guaranteed to be of type MyClass
, so one can iterate over it using a variable of type MyClass
public void doSomething(List extends MyClass> list)
However, it is not guaranteed that one can add any object of type MyClass
to that list:
public void doSomething(List extends MyClass> list)
The converse is true for lower bounds, which are specified using super
:
A List super MyClass>
is a list of objects of some superclass of MyClass
, i.e. the list is guaranteed to be able to contain any object of type MyClass
, so one can add any object of type MyClass
:
public void doSomething(List super MyClass> list)
However, it is not guaranteed that one can iterate over that list using a variable of type MyClass
:
public void doSomething(List super MyClass> list)
In order to be able to do both add objects of type MyClass
to the list and iterate over it using a variable of type MyClass
, a List
is needed, which is the only type of List
that is both List extends MyClass>
and List super MyClass>
. Java syntax(Generics)
The mnemonics PECS (Producer Extends, Consumer Super) from the book Effective Java by Joshua Bloch gives an easy way to remember when to use wildcards (corresponding to Covariance and Contravariance) in Java.
See also
* Bounded quantification
In type theory, bounded quantification (also bounded polymorphism or constrained genericity) refers to universal or existential quantifiers which are restricted ("bounded") to range only over the subtypes of a particular type. Bounded quantificat ...
* Covariance and contravariance (computer science)
Many programming language type systems support subtyping. For instance, if the type is a subtype of , then an expression of type should be substitutable wherever an expression of type is used.
Variance refers to how subtyping between more c ...
* Generics in Java#Type wildcards section explains lower and upper wildcard bounds
References
* The Java Language Specification, Third Edition (Sun), http://java.sun.com/docs/books/jls/
* Java Tutorials, Lesson Generics http://download.oracle.com/javase/tutorial/java/generics/index.html
* Capturing Wildcards, http://bayou.io/draft/Capturing_Wildcards.html
* Typkompatibilität in Java http://public.beuth-hochschule.de/~solymosi/veroeff/typkompatibilitaet/Typkompatibilitaet.html#Joker (in German)
{{DEFAULTSORT:Wildcard (Java)
Java (programming language)
Polymorphism (computer science)
Articles with example Java code