Table of Contents
This section provides the essential information about generics in Java 5 needed to understand how generics are treated in AspectJ 5. For a full introduction to generics in Java, please see the documentation for the Java 5 SDK.
A generic type is declared with one or more type parameters following the type name.
By convention formal type parameters are named using a single letter, though this is not required.
A simple generic list type
(that can contain elements of any type E
) could be declared:
interface List<E> { Iterator<E> iterator(); void add(E anItem); E remove(E anItem); }
It is important to understand that unlike template mechanisms there will only be one type, and one class file, corresponding to
the List
interface, regardless of how many different instantiations of the List
interface a program
has (each potentially providing a different value for the type parameter E
). A consequence of this
is that you cannot refer to the type parameters of a type declaration in a static method or initializer, or in the declaration or
initializer of a static variable.
A parameterized type
is an invocation of a generic type with concrete values supplied for
all of its type parameters (for example, List<String>
or List<Food>
).
A generic type may be declared with multiple type parameters. In addition to simple type parameter names, type
parameter declarations can also constrain the set of types allowed by using the extends
keyword. Some examples follow:
A class Foo
with one type parameter, T
.
A class Foo
with two type parameters, T
and S
.
A class Foo
with one type parameter T
, where T
must be
instantiated as the type Number
or a subtype of Number
.
A class Foo
with two type parameters, T
and S
. Foo
must be instantiated with a type S
that is a subtype of the type specified for parameter T
.
A class Foo
with one type parameter, T
. Foo
must be instantiated with a type that is a subtype of Number
and that implements Comparable
.
You declare a variable (or a method/constructor argument) of a parameterized type by specifying a concrete type specfication for each type parameter in the generic type. The following example declares a list of strings and a list of numbers:
List<String> strings; List<Number> numbers;
It is also possible to declare a variable of a generic type without specifying any values for the type
parameters (a raw type). For example, List strings
.
In this case, unchecked warnings may be issued by the compiler
when the referenced object is passed as a parameter to a method expecting a parameterized type such as a
List<String>
. New code written in the Java 5 language would not be expected to use
raw types.
Parameterized types are instantiated by specifying type parameter values in the constructor call expression as in the following examples:
List<String> strings = new MyListImpl<String>(); List<Number> numbers = new MyListImpl<Number>();
When declaring parameterized types, the ?
wildcard may be used, which stands for "some type".
The extends
and super
keywords may be used in conjunction with the wildcard
to provide upper and lower bounds on the types that may satisfy the type constraints. For example:
A list containing elements of some type, the type of the elements in the list is unknown.
A list containing elements of some type that extends Number, the exact type of the elements in the list is unknown.
A list containing elements of some type that is a super-type of Double, the exact type of the elements in the list is unknown.
A generic type may be extended as any other type. Given a generic type Foo<T>
then
a subtype Goo
may be declared in one of the following ways:
Here Foo
is used as a raw type, and the appropriate warning messages will be
issued by the compiler on attempting to invoke methods in Foo
.
Goo
is a generic type, but the super-type Foo
is used as a raw
type and the appropriate warning messages will be
issued by the compiler on attempting to invoke methods defined by Foo
.
This is the most usual form. Goo
is a generic type with one parameter that extends
the generic type Foo
with that same parameter. So Goo<String<
is
a subclass of Foo<String>
.
Goo
is a generic type with two parameters that extends
the generic type Foo
with the first type parameter of Goo
being used
to parameterize Foo
. So Goo<String,Integer<
is
a subclass of Foo<String>
.
Goo
is a type that extends
the parameterized type Foo<String>
.
A generic type may implement one or more generic interfaces, following the type binding
rules given above. A type may also implement one or more parameterized interfaces (for example,
class X implements List<String>
, however a type may not at the same time
be a subtype of two interface types which are different parameterizations of the same interface.
The supertype of a generic type C
is the type given in the extends clause of
C
, or Object
if no extends clause is present. Given the type declaration
public interface List<E> extends Collection<E> {... }
then the supertype of List<E>
is Collection<E>
.
The supertype of a parameterized type P
is the type given in the extends clause of
P
, or Object
if no extends clause is present. Any type parameters in
the supertype are substituted in accordance with the parameterization of P
. An example
will make this much clearer: Given the type List<Double>
and the definition of
the List
given above, the direct supertype is
Collection<Double>
. List<Double>
is not
considered to be a subtype of List<Number>
.
An instance of a parameterized type P<T1,T2,...Tn>
may be assigned to a variable of
the same type or a supertype
without casting. In addition it may be assigned to a variable R<S1,S2,...Sm>
where
R
is a supertype of P
(the supertype relationship is reflexive),
m <= n
, and for all type parameters S1..m
, Tm
equals
Sm
or Sm
is a wildcard type specification and
Tm
falls within the bounds of the wildcard. For example, List<String>
can be assigned to a variable of type Collection<?>
, and List<Double>
can be assigned to a variable of type List<? extends Number>
.
A static method may be declared with one or more type parameters as in the following declaration:
static <T> T first(List<T> ts) { ... }
Such a definition can appear in any type, the type parameter T
does not need to
be declared as a type parameter of the enclosing type.
Non-static methods may also be declared with one or more type parameters in a similar fashion:
<T extends Number> T max(T t1, T t2) { ... }
The same technique can be used to declare a generic constructor.
Generics in Java are implemented using a technique called erasure. All
type parameter information is erased from the run-time type system. Asking an object of a parameterized
type for its class will return the class object for the raw type (eg. List
for an object
declared to be of type List<String>
. A consequence of this is that you cannot at
runtime ask if an object is an instanceof
a parameterized type.