public void printPair( Pair<String,Long><\/span> <\/b> pair) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Pair<String,Long><\/span> <\/b> limit = new Pair<String,Long><\/span> <\/b> (\"maximum\",1024L);<\/tt>
\n printPair(limit);<\/tt><\/p><\/blockquote>\nExample (of a wildcard parameterized type):<\/p>\n
\n public void printPair( Pair<?,?><\/span> <\/b> pair) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Pair<?,?><\/span> <\/b> limit = new Pair<String,Long><\/span> <\/b> (\"maximum\",1024L);<\/tt>
\n printPair(limit);<\/tt><\/p><\/blockquote>\n<\/blockquote>\nAll instantiations of a generic type share the same runtime type representation, namely the representation of the raw type. For instance, the instantiations of a generic type List<\/tt> , such as List<Date><\/tt> , List<String><\/tt> , List<Long><\/tt> , etc. have different static types at compile time, but the same dynamic type List <\/tt> at runtime.<\/p>\n
A cast consists of two parts:<\/p>\n
\n- a static type check performed by the compiler at compile time and<\/li>\n
- a dynamic type check performed by the virtual machine at runtime.<\/li>\n<\/ul>\n
The static part sorts out nonsensical casts, that cannot succeed, such as the cast from String<\/tt> that Date<\/tt> or from List<String><\/tt> that List<Date><\/tt> .<\/p>\n
The dynamic part uses the runtime type information and performs a type check at runtime.\u00a0 It raises a ClassCastException<\/tt> if the dynamic type of the object is not the target type (or a subtype of the target type) of the cast. Examples of casts with a dynamic part are the cast from Object<\/tt> that String<\/tt> or from Object<\/tt> that List<String><\/tt> .\u00a0 These are the so-called downcasts, from a supertype down to a subtype.<\/p>\n
Examples of concrete parameterized types are List<String><\/tt> , Map<String,Date><\/tt> , but not List<? extends Number><\/tt> or Map<String,?><\/tt> .<\/p>\n
It is sometimes expected that a List<Object><\/tt> would be a supertype of a List<String><\/tt> , because Object<\/tt> is a supertype of String<\/tt> .\u00a0 This expectation stems from the fact that such a type of relationship exists for arrays:\u00a0 Object[]<\/tt> is a supertype of String[]<\/tt> , because Object<\/tt> is a supertype of String<\/tt> . (This type of relationship is known as covariance<\/i> .) The super-subtype-relationship of the component types extends into the corresponding array types. No such a type relationship exists for instantiations of generic types. (Parameterized types are not<\/i> covariant.)<\/p>\n
The lack of a super-subtype-relationship among instantiations of the same generic type has various consequences.\u00a0 Here is an example.<\/p>\n
Example:<\/p>\n
void printAll(ArrayList<Object> c) {<\/tt>
\n \u00a0 for (Object o : c)\u00a0<\/tt>
\n \u00a0\u00a0\u00a0 System.out.println(o);<\/tt>
\n }<\/tt> ArrayList<String> list = new ArrayList<String>();<\/tt>
\n ... fill list ...<\/tt>
\n printAll(list);\u00a0\u00a0 \/\/ error<\/tt><\/p>\n
A ArrayList<String><\/tt> object cannot be passed as argument to a method that asks for a ArrayList<Object><\/tt> because the two types are instantiations of the same generic type, but for different<\/i> type arguments, and for this reason they are not compatible with each other.<\/p>\n
Concrete parameterized types are concrete instantiations of a generic type.\u00a0 They are almost like types; there are only a few restrictions.\u00a0 They can NOT be used for the following purposes:<\/p>\n
\n- for creation of arrays<\/li>\n
- in exception handling<\/li>\n
- in a class literal<\/li>\n
- in an instanceof<\/tt> expression<\/li>\n<\/ul>\n
Arrays holding elements whose type is a concrete parameterized type are illegal.<\/p>\n
Example (of illegal array type):<\/p>\n
static void test() {<\/tt>
\n \u00a0 Pair<Integer,Integer>[]<\/span> <\/b> intPairArr = new Pair<Integer,Integer>[10]<\/span> <\/b> ; \/\/ error<\/span> <\/b> <\/tt>
\n \u00a0 addElements(intPairArr);\u00a0<\/tt>
\n \u00a0 Pair<Integer,Integer> pair = intPairArr[1];<\/tt>
\n \u00a0 Integer i = pair.getFirst();<\/tt>
\n \u00a0 pair.setSecond(i);<\/tt>
\n }<\/tt>
\n static void addElements( Object[]<\/b> objArr) {<\/tt>
\n \u00a0 objArr[0] = new Pair<Integer,Integer>(0,0);<\/tt>
\n \u00a0 objArr[1] = new Pair<String,String>(\"\",\"\");\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ should fail with ArrayStoreException<\/tt>
\n }<\/tt><\/p>\nThe compiler prohibits creation of arrays whose component type is a concrete parameterized type, like Pair<Integer,Integer><\/tt> in our example.\u00a0 We discussed in the preceding entry why it is reasonable that the compiler qualifies a Pair<Integer,Integer>[]<\/tt> <\/span> as illegal.\u00a0 The key problem is that the compiler and runtime system must ensure that an array is a homogeneous<\/i> sequence of elements of the same type.\u00a0 One of the type checks, namely the array-store-check performed by the virtual machine at runtime, fails to detect the offending insertion of an alien element. In the example the second insertion in the addElements<\/tt> method should fail, because they were adding a pair of strings to an array of integral values, but it does not fail as expected. The reasons were discussed in the preceding entry.<\/p>\nIf we cannot use arrays holding elements whose type is a concrete parameterized type, what do we use as a workaround?<\/p>\n
Let us consider 3 conceivable workarounds:<\/p>\n
\n- array of raw types<\/li>\n
- array of unbounded wildcard parameterized type<\/li>\n
- collection instead of array<\/li>\n<\/ul>\n
While arrays of concrete parameterized types are illegal, collections of concrete parameterized types are permitted.<\/p>\n
A wildcard parameterized type is an instantiation of a generic type where at least one type argument is a wildcard.\u00a0 Examples of wildcard parameterized types are Collection<?><\/tt> , List<? extends Number><\/tt> , Comparator<? super String><\/tt> and Pair<String,?><\/tt> . A wildcard parameterized type denotes a family of types comprising concrete instantiations of a generic type.\u00a0 The kind of the wildcard being used determines which concrete parameterized types belong to the family.\u00a0 For instance, the wildcard parameterized type Collection<?><\/tt> denotes the family of all instantiations of the Collection<\/tt> interface regardless of the type argument.\u00a0 The wildcard parameterized type List<? extends Number><\/tt> denotes the family of all list types where the element type is a subtype of\u00a0 Number<\/tt> .\u00a0 The wildcard parameterized type Comparator<? super String><\/tt> is the family of all instantiations of the Comparator<\/tt> interface for type argument types that are supertypes of String.<\/tt><\/p>\n
A wildcard parameterized type is not a type in the regular sense (different from a non-parameterized class\/interface or a raw type).<\/em> <\/strong><\/p>\nWildcard parameterized types can be used for typing (like non-parameterized classes and interfaces):<\/p>\n
\n- as argument and return types of methods<\/li>\n
- as type of a field or local reference variable<\/li>\n
- as component type of an arrayas type argument of other parameterized types<\/li>\n
- as target type in casts<\/li>\n<\/ul>\n
Not only types can be generic, but methods can be generic, too. Static and non-static methods as well as constructors can have type parameters. The syntax for declaration of the formal type parameters is similar to the syntax for generic types. The type parameter section is delimited by angle brackets and appears before the method’s return type. Its syntax and meaning is identical to the type parameter list of a generic type.<\/p>\n
Here is the example of a generic max<\/tt> method that computes the greatest value in a collection of elements of an unknown type A<\/tt> .<\/p>\n
Example (of a generic method):<\/p>\n
class Collections {<\/tt>
\n \u00a0 public static <A extends Comparable<A>> A<\/span> <\/b> max(Collection< A<\/span> <\/b> > xs) {<\/tt>
\n \u00a0\u00a0\u00a0 Iterator< A<\/span> <\/b> > xi = xs.iterator();<\/tt>
\n \u00a0\u00a0\u00a0 A<\/span> <\/b> w = xi.next();<\/tt>
\n \u00a0\u00a0\u00a0 while (xi.hasNext()) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 A<\/span> <\/b> x = xi.next();<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 if (w.compareTo(x) < 0) w = x;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0 return w;<\/tt>
\n \u00a0 }<\/tt>
\n }\u00a0<\/tt><\/p><\/blockquote>\nThe max<\/tt> method has one type parameter, named A<\/tt> .\u00a0 It is a place holder for the element type of the collection that the method works on. The type parameter has a bound; it must be a type that is a subtype of Comparable<A><\/tt><\/p>\n
Example (of the same generic type, this time with<\/i> bounds):<\/p>\n public interface Comparable<T> {<\/tt>
\n \u00a0 public int compareTo(T arg);<\/tt>
\n }<\/tt>
\n public class TreeMap<Key extends Comparable<Key><\/span> <\/b> ,Data>{<\/tt>
\n \u00a0 private static class Entry<K,V> {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 K key;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 V value;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Entry<K,V> left = null;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Entry<K,V> right = null;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Entry<K,V> parent;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 private transient Entry<Key,Data> root = null;<\/tt>
\n \u00a0 ...<\/tt>
\n \u00a0 private Entry<Key,Data> getEntry(Key key) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Entry<Key,Data> p = root;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Key k = key;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 while (p != null) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 int cmp = k. compareTo(p.key)<\/span> <\/b> ;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 if (cmp == 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 return p;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 else if (cmp < 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 p = p.left;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 else\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 p = p.right;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 return null;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 public boolean containsKey(Key key) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 return getEntry(key) != null;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\nIn the example above, the type parameter Key<\/tt> has the bound Comparable<Key><\/tt> .\u00a0 Specification of a bound has two effects:<\/p>\n\n- It gives access to the methods that the bound specifies<\/i> .\u00a0 In the example, the bound Comparable<Key> <\/tt> gives access to the compareTo<\/tt> method that we want to invoke in the implementation of our TreeMap<\/tt> class.<\/li>\n<\/ul>\n
\n- Only types “within bounds” can be used for instantiation of the generic type.<\/i> \u00a0 In the example, a parameterized type such as TreeMap<Number,String><\/tt> would be rejected, because the type Number<\/tt> is not a subtype of Comparable<Number><\/tt> .\u00a0 A parameterized type like TreeMap<String,String><\/tt> would be accepted, because the type String is within bounds, i.e. is a subtype of Comparable<String><\/tt> .<\/li>\n<\/ul>\n
All classes, interfaces, and enum types can be used as type parameter bound, including nested and inner types.\u00a0 Neither primitive types nor array types be used as type parameter bound.<\/p>\n
Examples (of type parameter bounds):<\/p>\n
class X0 <T extends int<\/span> <\/b> > { ... }\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ error<\/span> <\/b> <\/tt>
\n class X1 <T extends Object[]<\/span> <\/b> > { ... } \/\/ error<\/span> <\/b> <\/tt>
\n class X2 <T extends Number<\/span> <\/b> > { ... }<\/tt>
\n class X3 <T extends String<\/span> <\/b> > { ... }<\/tt>
\n class X4 <T extends Runnable<\/span> <\/b> > { ... }<\/tt>
\n class X5 <T extends Thread.State<\/span> <\/b> > { ... }<\/tt>
\n class X6 <T extends List<\/span> <\/b> > { ... }<\/tt>
\n class X7 <T extends List<String><\/span> <\/b> > { ... }<\/tt>
\n class X8 <T extends List<? extends Number><\/span> <\/b> > { ... }<\/tt>
\n class X9 <T extends Comparable<? super Number><\/span> <\/b> > { ... }<\/tt>
\n class X10<T extends Map.Entry<?,?><\/span> <\/b> > { ... }<\/tt><\/p><\/blockquote>\nThe code sample shows that primitive types such as int<\/tt> and array types such as Object[] <\/tt> are not permitted as type parameter bound.<\/p>\n
Class types, such as Number<\/tt> or String<\/tt> , and interface types, such as Runnable<\/tt> , are permitted as type parameter bound.<\/p>\n
Enum types, such as Thread.State<\/tt> are also permitted as type parameter bound. Thread.State<\/tt> is an example of a nested type used as type parameter bound.\u00a0 Non-static inner types are also permitted.<\/p>\n
Raw types are permitted as type parameter bound; List<\/span> <\/tt> is an example.<\/p>\nParameterized types are permitted as type parameter bound, including concrete parameterized types such as List<String><\/tt> , bounded wildcard parameterized types such as List<? extends Number><\/tt> and Comparable<? super Long><\/tt> , and unbounded wildcard parameterized types such as Map.Entry<?,?><\/tt> .\u00a0 A bound that is a wildcard parameterized type allows as type argument all types that belong to the type family that the wildcard denotes.\u00a0 The wildcard parameterized type bound gives only restricted access to fields and methods; the restrictions depend on the kind of wildcard.<\/p>\n
Example (of wildcard parameterized type as type parameter bound):<\/p>\n
class X< T extends List<? extends Number><\/span> <\/b> > {<\/tt>
\n \u00a0 public void someMethod(T t) {<\/tt>
\n \u00a0\u00a0\u00a0 t.add(new Long(0L));\u00a0\u00a0\u00a0 \/\/ error<\/span> <\/b> <\/tt>
\n \u00a0\u00a0\u00a0 Number n = t.remove(0);<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt>
\n class Test {<\/tt>
\n \u00a0 public static void main(String[] args) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 <\/span> <\/b> X<ArrayList<<\/span> Long<\/span> <\/b> >> x1 = new X<ArrayList<Long>>();\u00a0<\/span> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0 X<ArrayList<<\/span> String<\/span> <\/b> >> x2 = new X<ArrayList<String>>(); <\/span> \/\/ error<\/span> <\/b> <\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nReference variables of type T <\/tt> (the type parameter) are treated like reference variables of a wildcard type (the type parameter bound).\u00a0 In our example the consequence is that the compiler rejects invocation of methods that take an argument of the “unknown” type that the type parameter stands for, such as List.add<\/tt> , because the bound is a wildcard parameterized type with an upper bound.
\nAt the same time the bound List<? extends Number><\/tt> determines the types that can be used as type arguments. The compiler accepts all type arguments that belong to the type family List<? extends Number><\/tt> , that is, all subtypes of List<\/tt> with a type argument that is a subtype of Number<\/tt> .<\/p>\n
A type parameter can be used as the bound of another type parameter.<\/p>\n
Example (of a type parameter used as a type parameter bound):<\/p>\n
class Triple <T><\/b> {<\/tt>
\n \u00a0 private T fst, snd, trd;<\/tt>
\n \u00a0 public < U<\/b> extends T<\/span> <\/b> , V extends T<\/span> <\/b> , W extends T<\/span> <\/b> > Triple(U arg1, V arg2, W arg3) {<\/tt>
\n \u00a0\u00a0\u00a0 fst = arg1;<\/tt>
\n \u00a0\u00a0\u00a0 snd = arg2;<\/tt>
\n \u00a0\u00a0\u00a0 trd = arg3;<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nIn this example the type parameter T<\/tt> of the parameterized class is used as bound of the type parameters U<\/tt> ,\u00a0 V<\/tt> and W<\/tt> of a parameterized instance method of that class.<\/p>\n
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.\u00a0 It is even permitted to use a type parameter as bound of another type parameter in the same type parameter section.<\/p>\n
A bound that is a class gives access to all its public members, that is, public fields, methods, and nested types. Only constructors are not made accessible, because there is no guarantee that a subclass of the bound has the same constructors as the bound.<\/p>\n
Example (of a class used as bound of a type parameter):<\/p>\n
public class SuperClass<\/span> {<\/tt> \u00a0\u00a0\u00a0 \/\/ static members<\/tt>
\n \u00a0\u00a0\u00a0 public enum EnumType {THIS, THAT}<\/tt>
\n \u00a0\u00a0\u00a0 public static Object staticField;<\/tt>
\n \u00a0\u00a0\u00a0 public static void staticMethod() { ... }<\/tt><\/p>\n \u00a0\u00a0\u00a0 \/\/ non-static members<\/tt>
\n \u00a0\u00a0\u00a0 public class InnerClass { ... }<\/tt>
\n \u00a0\u00a0\u00a0 public Object nonStaticField;<\/tt>
\n \u00a0\u00a0\u00a0 public void nonStaticMethod() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ constructors<\/tt>
\n \u00a0\u00a0\u00a0 public SuperClass() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ private members<\/tt>
\n \u00a0\u00a0\u00a0 private Object privateField;\u00a0<\/tt><\/p>\n
\u00a0\u00a0\u00a0 ...<\/tt>
\n }<\/tt><\/p>\n
public final class SomeClass<T extends SuperClass<\/span> <\/b> > {<\/tt>
\n \u00a0\u00a0\u00a0 private T object;<\/tt>
\n \u00a0\u00a0\u00a0 public SomeClass(T t) { object = t; }\u00a0<\/tt><\/p>\n \u00a0\u00a0\u00a0 public String toString() {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 return<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \"static nested type\u00a0\u00a0\u00a0 : \"+T.EnumType.class+\"\\n\"\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"static field\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+T.staticField+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"static method\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+T.staticMethod()+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"non-static nested type: \"+T.InnerClass.class+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"non-static field\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticField+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"non-static method\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticMethod()+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"constructor\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+(new T())+\"\\n\"\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ error<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"private member\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.privateField+\"\\n\"\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ error\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
The bound SuperClass<\/tt> gives access to its nested types, static fields and methods and non-static fields and methods.\u00a0 Only the constructor is not accessible.\u00a0 This is because constructors are not inherited. Each subclass defines its own constructors and need not support its superclass’s constructors.\u00a0 Hence there is no guarantee that a subclass of SuperClass<\/tt> will have the same constructor as its superclass.<\/p>\n
The context in which Enum<E extends Enum<E>><\/tt> ” appears is the declaration of the Enum<\/tt> class in package java.lang<\/tt> :<\/p>\n public abstract class Enum<E extends Enum<E>><\/b> {<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
The type Enum<\/tt> is the common base class of all enumeration types.\u00a0 In Java an enumeration type such as Color<\/tt> is translated into a class Color<\/tt> that extends Enum<Color><\/tt> . The purpose of the superclass Enum<\/tt> is to provide functionality that is common to all enumeration types.<\/p>\n
Here is a sketch of class Enum<\/tt> :<\/p>\n public abstract class Enum< E<\/span> extends Enum<E>><\/b> implements Comparable< E<\/span> <\/b> >, Serializable {<\/tt>
\n \u00a0 private final String name;<\/tt>
\n \u00a0 public final String name() { ... }<\/tt> \u00a0 private final int ordinal;<\/tt>
\n \u00a0 public final int ordinal() { ... }<\/tt><\/p>\n \u00a0 protected Enum(String name, int ordinal) { ... }<\/tt><\/p>\n
\u00a0 public String\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 toString() { ... }<\/tt>
\n \u00a0 public final boolean equals(Object other) { ... }<\/tt>
\n \u00a0 public final int hashCode() { ... }<\/tt>
\n \u00a0 protected final Object clone() throws CloneNotSupportedException { ... }<\/tt>
\n \u00a0 public final int compareTo( E<\/span> <\/b> o) { ... }<\/tt><\/p>\n \u00a0 public final Class< E<\/span> <\/b> > getDeclaringClass() { ... }<\/tt>
\n \u00a0 public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) { ... }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nThe surprising feature in the declaration “ Enum<E extends Enum<E>><\/tt> ” is the fact that the newly defined class Enum<\/tt> and its newly defined type parameter E <\/tt> appear in the bound of that same type parameter.\u00a0 It means that the Enum<\/tt> type must be instantiated for one of its subtypes.\u00a0 In order to understand why this makes sense, consider that every enum type is translated into a subtype of Enum<\/tt> .<\/p>\n
Here is the contrived enum type Color<\/tt> :<\/p>\n enum Color<\/b> {RED, BLUE, GREEN}<\/tt><\/p><\/blockquote>\n
The compiler translates it into the following class:<\/p>\n
public final class Color<\/b> extends Enum<Color><\/b> {<\/tt>
\n \u00a0 public static final Color[] values() { return (Color[])$VALUES.clone(); }<\/tt>
\n \u00a0 public static Color valueOf(String name) { ... }<\/tt> \u00a0 private Color(String s, int i) { super(s, i); }<\/tt><\/p>\n
\u00a0 public static final Color RED;<\/tt>
\n \u00a0 public static final Color BLUE;<\/tt>
\n \u00a0 public static final Color GREEN;<\/tt><\/p>\n
\u00a0 private static final Color $VALUES[];<\/tt><\/p>\n
\u00a0 static {<\/tt>
\n \u00a0\u00a0\u00a0 RED = new Color(\"RED\", 0);<\/tt>
\n \u00a0\u00a0\u00a0 BLUE = new Color(\"BLUE\", 1);<\/tt>
\n \u00a0\u00a0\u00a0 GREEN = new Color(\"GREEN\", 2);<\/tt>
\n \u00a0\u00a0\u00a0 $VALUES = (new Color[] { RED, BLUE, GREEN });<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
The inheritance has the effect that the Color<\/tt> type inherits all the methods implemented in Enum<Color><\/tt> .\u00a0 Among them is the compareTo<\/tt> method.\u00a0 The Color. compareTo<\/tt> method should probably take a Color<\/tt> as an argument.\u00a0 In order to make this happen class Enum<\/tt> is generic and the Enum.compareTo<\/tt> method takes Enum<\/tt> ‘s type parameter E <\/tt> as an argument.\u00a0 As a result, type Color<\/tt> derived from Enum<Color><\/tt> inherits a compareTo<\/tt> method that takes a Color<\/tt> as and argument, exactly as it should.
\nIf we dissect the declaration “ Enum<E extends Enum<E>><\/tt> ” we can see that this pattern has several aspects.<\/p>\n
First, there is the fact that the type parameter bound is the type itself: “ Enum<\/b> <E extends Enum<\/b> <E>><\/tt> “. It makes sure that only subtypes of type Enum<\/tt> are permitted as type arguments. (Theoretically, type Enum<\/tt> could be instantiated on itself, like in Enum<Enum><\/tt> , but this is certainly not intended and it is hard to imagine a situation in which such an instantiation would be useful.)<\/p>\n
Second, there is the fact that the parameter bound type is the parameterized type Enum <E><\/b> <\/tt> , which uses the type parameter E<\/tt> as the type argument of the bound. This declaration makes sure that the inheritance relationship between a subtype and an instantiation of Enum<\/tt> is of the form X extends Enum<X><\/tt> “. A subtype such as “ X extends Enum<Y><\/tt> ” cannot be declared because of the type argument Y<\/tt> would not be within bounds; only subtypes of Enum<X><\/tt> are within bounds.<\/p>\n
Third, there is the fact that Enum<\/tt> is generic in the first place.\u00a0 It means that some of the methods of class Enum<\/tt> 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<\/tt> of Enum<X><\/tt> .\u00a0 Hence, in the parameterized type Enum<X><\/tt> , these methods involve the subtype X<\/tt> , and they are inherited into the subtype X<\/tt> .\u00a0 The compareTo<\/tt> 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.<\/p>\n
To sum it up, the declaration “ Enum<E extends Enum<E>><\/tt> ” can be deciphered as: Enum<\/tt> 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).<\/p>\n
Lower Bound Type Parameters of Classes<\/b><\/p>\n
Type parameters can have several bounds, like in class Box<T extends Number> {...}<\/tt> . But a type parameter can have no lower bound, that is, a construct such as class Box<T great<\/b> Number> {...}<\/tt> is not permitted.\u00a0 Why not?\u00a0 The answer is: it is pointless because it would not buy you anything, were it allowed.\u00a0 Let us see why lower bound type parameters of classes are confusing by exploring what an upper bound on a type parameter means.<\/p>\n
The upper bound on a type parameter has three effects:<\/p>\n
\n\n- Restricted Instantiation.<\/i> <\/b> The upper bound restricts the set of types that can be used for instantiation of the generic type.\u00a0 If we declare a class Box<T extends Number> {...} <\/tt> then the compiler would ensure that only subtypes of Number<\/tt> can be used as type argument.\u00a0 That is, a Box<Number><\/tt> or a Box<Long><\/tt> is permitted, but a Box<Object><\/tt> or Box<String><\/tt> would be rejected<\/li>\n<\/ol>\n<\/ol>\n
Example (of restricted instantiation due to an upper bound on a type parameter):
\n class Box<T extends Number> {\u00a0<\/tt>
\n \u00a0\u00a0 private T value;\u00a0<\/tt>
\n \u00a0\u00a0 public Box(T t) { value = t; }\u00a0<\/tt>
\n \u00a0\u00a0 ...<\/tt>
\n }\u00a0<\/tt> class Test {\u00a0<\/tt>
\n \u00a0\u00a0 public static void main(String[] args) {\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<Long> boxOfLong = new Box<Long>(0L);\u00a0\u00a0 \/\/ fine<\/b> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<String> boxOfString = new Box<String>(\"\"); \/\/ error: String is not within bounds<\/span> <\/b> <\/tt>
\n \u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p>\n\n- Access To Non-Static Members. <\/i> <\/b> The upper bound gives access to all public non-static methods and fields of the upper bound.\u00a0 In the implementation of our class Box<T extends Number> {...}<\/tt> we can invoke all public non-static methods defined in class Number<\/tt> , such as intValue()<\/tt> for instance.\u00a0 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):<\/li>\n<\/ol>\n
class Box<T extends Number> {\u00a0<\/tt>
\n \u00a0\u00a0 private T value;\u00a0<\/tt>
\n \u00a0\u00a0 public Box(T t) { value = t; }\u00a0<\/tt>
\n \u00a0\u00a0 public int increment() { return value.intValue()+1; } \/\/ <= would be an error without the Number bound<\/b> <\/tt>
\n \u00a0\u00a0 ...<\/tt>