Earlier in this chapter we saw the constraint T extends Comparable<T>, which is also a recursive bound Another example of recursive bounds is the declaration of the Enum<E extends Enum<E>> class in the Java Standard Library

Understanding translation by type erasure helps to understand the restrictions and limitations that arise when using generics in Java Although the compiler generates generic-free byte code, we can view the process as a source-to-source translation that generates non-generic code from generic code The translated code has no information about type parameters, ie, the type parameters have been erased hence the term, type erasure This involves replacing the usage of the type parameters with concrete types and inserting suitable type conversions to ensure type correctness In certain situations, bridge methods are also inserted for backward compatibility The process of determining the erasure of a type, ie, what a type in the source code should be replaced with, uses the following rules: 1 2 Drop all type parameter specifications from parameterized types Replace any type parameter as follows: a Replace it with the erasure of its bound, if it has one b Replace it with Object, if it has none c Replace it with the erasure of the first bound, if it has multiple bounds Table 144 shows examples of translation by erasure for some representative types, and the rules that are applied

List<E> List<Integer> List<String> List<List<String>> List< super Integer> List< extends Number> List<Integer>[] List int Integer List

1 1 For any primitive type For any non-generic type (continues)

class Subclass extends Superclass implements Comparable<Subclass> {} public static <T extends Comparable< super T>> T max(T obj1, T obj2) { } public static <T> T doIt(T t) { T lv = t; } T extends MyClass & Comparable<T> & Serializable

class Subclass extends Superclass implements Comparable {} public static Comparable max(Comparable obj1, Comparable obj2) { } public static Object doIt(Object t) { Object lv = t; } MyClass

The following code mixes legacy and generic code Note that a ClassCastException is expected at (5) because the type-safety of the stack of String has been compromised

// Pre-erasure code List<String> strList = new ArrayList<String>(); // (0) List list = strList; // (1) Assignment to non-generic reference is ok strList = list; // (2) warning: unchecked conversion strListadd("aha"); // (3) Method call type-safe listadd(23); // (4) warning: [unchecked] unchecked call to add(E) // as a member of the raw type javautilList Systemoutprintln(strListget(1)length()); // (5) ClassCastException

It is instructive to compare the corresponding lines of code in the pre-erasure code above and the post-erasure results shown below A cast is inserted to convert from Object type to String type in (5') This is necessary because post-erasure code can only get an Object from the list, and in order to call the length() method, the reference value of this object must be converted to String It is this cast that is the cause of the exception at runtime

// Post-erasure code List strList = new ArrayList(); List list = strList; strList = list; strListadd("aha"); listadd(IntegervalueOf(23)); Systemoutprintln(((String)strListget(1))length()); // // // // // // (0') (1') (2') (3') (4') (5')

Bridge methods are inserted in subclasses by the compiler to ensure that overriding of method works correctly The canonical example is the implementation of the Comparable interface The post-erasure code of the class CmpNode<E> from Section 146 on page 684 is shown below A second compareTo() method has been inserted by the compiler at (2), whose method signature is compareTo(Object) This is necessary because, without this method, the class would not implement the Comparable interface, as the compareTo() method of the interface would not be overridden correctly

class CmpNode extends Node implements Comparable { CmpNode(Object data, CmpNode next) { super(data, next); } public int compareTo(CmpNode node2) { // (1) return thisgetData()compareTo(node2getData()); } public int compareTo(Object node2) { // (2) return thiscompareTo((CmpNode)node2); // Calls the method at (1) } }

Such a bridge method cannot be invoked in the source code, and is provided for backward compatibility with legacy code There are Java decompilers readily available that can be used to examine the code generated by the compiler