Java Brand Generics. Advanced Topics in Java. Khalid Azim Mughal Version date:

Transcription

1 Java Brand Generics Advanced Topics in Java Khalid Azim Mughal Version date: Khalid Azim Mughal Java Brand Generics 1/40 Overview Introduction to Generics Basic Java Generics Increasing Expressive Power with Wildcard Type Parameters Generic Interfaces Generic Methods Translation by Type Erasure Other Implications and Restrictions regarding Java Generics Further Study and Resources Khalid Azim Mughal Java Brand Generics 2/40

2 INTRODUCTION TO GENERICS The Role of Generics in Programming Languages Java Brand of Generics Khalid Azim Mughal Java Brand Generics 3/40 The Role of Generics in Programming Languages Generics 1 allow definition and implementation of generic abstractions. The generic type is parameterized by one or more formal type parameters. The actual type parameters are supplied when the generic type is instantiated. A parameterized type thus represents a set of types depending on the actual type parameters supplied. Recurring theme in the evolution of programming languages For example: Ada, Clu, C++, C#, Eiffel, and now Java "One List to Rule Them All!" 1. a.k.a. Genericity, Parametric polymorphism Khalid Azim Mughal Java Brand Generics 4/40

3 Java Brand of Generics Goal: Provide extra type information at compile time to avoid verbosity and the necessity of explicit type checking and casting at runtime. Compile-time Java Generics (JG): Reference types (classes, interfaces and array types) and methods can be parameterized with type information. Generics implemented as compiler transformations, with insignificant impact on the JVM. Benefits: Increased language expressiveness with improved type safety Khalid Azim Mughal Java Brand Generics 5/40 BASIC JAVA GENERICS The Need for Generics Generic Types Parameterized Types Canonical usage with Collections Khalid Azim Mughal Java Brand Generics 6/40

4 Canonical Problem: Collections w/o Generics A collection without generics can hold references to objects of any type. List wordlist = new ArrayList(); // Using a generic reference for the list. wordlist.add("two zero zero five"); // Can add any object. wordlist.add(new Integer(2004)); //... Object element = wordlist.get(0); //... if (element instanceof String) { // Runtime check to avoid ClassCastException String strint = (String) element;// Cast required. //... Inheritance allows the implementation of the class to be specific, but its use to be generic. An ArrayList is a specific implementation of the List interface, usage of the class ArrayList is generic with regard to any object. Khalid Azim Mughal Java Brand Generics 7/40 Using parameterized types: Collections w/ Generics List<String> wordlist = new ArrayList<String>(); // Using a specific type. wordlist.add(c); // Can add only strings wordlist.add(new Integer(2004)); // Compile-time error! //... String element = wordlist.get(0); // Only strings as elements //... No runtime check or explicit cast necessary! Generic types allow the implementation of class to be generic, but its use to be specific. The generic type ArrayList<E> is a generic implementation of the List<E> interface, usage of the parameterized type ArrayList<String> is specific, as it constrains the generic type ArrayList<E> to strings. // Implementation in the java.util package public interface List<E> extends Collection<E> {... public class ArrayList<E> extends AbstractList<E> {... Khalid Azim Mughal Java Brand Generics 8/40

5 Generic Types and Parameterized Types A generic type is a reference type that defines a set of formal type parameters or type variables (E 1, E 2...E n ) that must be provided for its invocation. public class ArrayList<E> extends AbstractList<E> {... // (1) Declaration The (formal) type parameter is an unqualified identifier. The type parameter E can be used (pretty much) as any other type in the class, although a type parameter cannot be used to create a new instance. A generic type without its formal type parameters is called a raw type. ArrayList is the raw type of the generic type ArrayList<E>. An invocation or instantiation (usually called a parameterized type) is a specific usage of a generic type where the formal type parameters are replaced by actual type parameters. ArrayList<String> mylist = new ArrayList<String>(); // (2) Invocation Methods can be called on objects of generic types, no extra syntax is required: mylist.add("two zero zero five"); We can declare references of generic types, instantiate generic classes, and call methods on the objects. Khalid Azim Mughal Java Brand Generics 9/40 General Remarks on Java Generics The compiler ensures that the parameterized type is used correctly so that errors are caught at compile time, and not at runtime. Generics are implemented in the compiler; no generic type info is available at runtime. A parameterized type does not create a new class. The invocations share the generic type. Invocation of generic types is restricted to reference types (excluding array creation and enumerations), and primitive types are not permitted as type parameters. Khalid Azim Mughal Java Brand Generics 10/40

6 Example of legacy code: LegacySeq Any object can be maintained in a sequence, the client must do the bookkeeping. public class LegacySeq { private Object element; // Data private LegacySeq tail; // Rest of the sequence LegacySeq(Object element, LegacySeq tail) { this.element = element; this.tail = tail; public void setelement(object obj) { element = obj; public Object getelement() { return element; public void settail(legacyseq tail) { this.tail = tail; public LegacySeq gettail() { return this.tail; //... // Client code LegacySeq intseq = new LegacySeq(32, new LegacySeq(16, null)); intseq.setelement(8.5); // Any object can be added. Integer iref = (Integer) intseq.getelement(); // ClassCastException at runtime. Khalid Azim Mughal Java Brand Generics 11/40 Example of (naive) generic code: SimpleSeq public class SimpleSeq<T> { private T element; // Data private SimpleSeq<T> tail; // Rest of the sequence SimpleSeq(T element, SimpleSeq<T> tail) { this.element = element; this.tail = tail; public void setelement(t obj) { element = obj; public T getelement() { return element; public void settail(simpleseq<t> tail) { this.tail = tail; public SimpleSeq<T> gettail() { return this.tail; //... // Client code: declaring references and instantiating objects of generic classes SimpleSeq<Integer> intseq = new SimpleSeq<Integer>(10, null); // (1) SimpleSeq<Double> doubleseq = new SimpleSeq<Double>(20.5,null); // (2) SimpleSeq<Number> numseqa = new SimpleSeq<Number>(30.5, null); // (3) SimpleSeq<Number> numseqb = new SimpleSeq<Number>(30.5, numseqa); // (3) //SimpleSeq<Number> numseqc = new SimpleSeq<Number>(40.5, intseq); // (4) Huh? //SimpleSeq<Number> numseqd = doubleseq; // (5) Huh? Khalid Azim Mughal Java Brand Generics 12/40

7 Example of (naive) generic code: SimpleSeq (cont.) The generic type SimpleSeq<T> allows only a sequence of a specific type to be maintained. The scope of the type parameter T is the declaration of the generic type. All occurrences of the Object class in the LegacySeq class have been replaced by the type parameter T in the SimpleSeq class. The usage of the class name SimpleSeq is parameterized by the type parameter T in the class declaration. The type parameter T binds to the actual type parameter specified in the invocation of the generic type. Note that in the implementation of the generic type SimpleSeq<T>, we never invoke methods on objects of the type parameter T. This is not always the case in implementing generic types. Khalid Azim Mughal Java Brand Generics 13/40 No Subtype Covariance for "Pure" Parameterized Types Number Number[] SimpleSeq<Number> Integer Integer[] SimpleSeq<Integer> What is the problem? SimpleSeq<Integer> intseq = new SimpleSeq<Integer>(64, null); SimpleSeq<Number> numseq = intseq; // (1) DISALLOWED: compile-time error numseq.setelement(3.14); // (2) No runtime type info available Integer iref = intseq.getelement(); // (3) Runtime type error Khalid Azim Mughal Java Brand Generics 14/40

8 INCREASING EXPRESSIVE POWER WITH WILDCARD TYPE PARAMETERS Defining Variant Parametric Types with Wildcards Type Parameter Upper and Lower Bounds Understanding Subtype-Supertype Relationships involving Generic Types Using Wildcards Comparison to Interfaces Declaring References with Wild Cards Usage Restrictions Using Multiple Bounds Running example classes: class Seq<T> {... class SafeSeq<T> extends Seq<T> {... Khalid Azim Mughal Java Brand Generics 15/40 Type Specification Overview Name Syntax Semantics Description Subtype Covariance Subtype Contravariance Subtype Bivariance Subtype Invariance <? extends T> Any subtype of T Wildcard with upper bound <? super T> Any supertype of T Wildcard with lower bound <?> Any type Unbounded Wildcard <T> Only type T "Pure" generics Khalid Azim Mughal Java Brand Generics 16/40

9 Subtype Covariance: <? extends T> The subtype covariance relation is represented by the following bounded wildcard: <? extends T>? denotes an unknown type. T is called the upper bound. The wildcard <? extends T> means that any subtype of T (or T itself) is acceptable as an actual type parameter in the wildcard invocation. Example: The wildcard <? extends Number> denotes a family of subtypes of Number. The invocation Seq<? extends Number> denotes a set of invocations of Seq for types that are subtypes of Number. Seq<? extends Number>... Seq<Number> Seq<? extends Integer> Seq<Integer> Khalid Azim Mughal Java Brand Generics 17/40 Subtype Contravariance: <? super T> The subtype contravariance relation is represented by the following bounded wildcard: <? super T> T is called the lower bound. The wildcard <? super T> means that any supertype of T (or T itself) is acceptable as an actual type parameter in the wildcard invocation. Example: The wildcard <? super Integer> denotes a family of supertypes of Integer. The wildcard invocation Seq<? super Integer> denotes a set of invocations of Seq for types that are supertypes of Integer. Seq<? super Integer> Seq<Integer> Seq<? super Number> Seq<? super Comparable> Seq<Number> Seq<? super Object> Seq<Comparable> Seq<Object> Khalid Azim Mughal Java Brand Generics 18/40

10 Subtype Bivariance: <?> The subtype bivariance relation is represented by the unbounded wildcard, <?>. By definition, the bivariance relation is covariant and contravariant. It denotes the family of all types. Example: The wildcard invocation Seq<?> denotes the set of invocations of Seq for any type, i.e. denotes a Seq of anything. Subtype Invariance: <T> The subtype invariance relation is represented by <T>, there T is a specific type. The notation <T> means that only T is acceptable as an actual type parameter in the invocation. Example: "Pure" Generics The invocation Seq<Integer> denotes a set containing only the instantiation of Seq for the specified type parameter. Khalid Azim Mughal Java Brand Generics 19/40 Variant Parametric Type Hierarchy (partial view) Object Number Seq<?> Integer Seq<? extends Number> Seq<? super Integer> Seq<Number> Seq<? extends Integer> Seq<? super Number> Seq<Integer> Seq<? super Object> Seq<Object> Khalid Azim Mughal Java Brand Generics 20/40

11 Generic Class Seq<T> public class Seq<T> { private T element; // Data private Seq<? extends T> tail; // Rest of the sequence Seq(T element, Seq<? extends T> tail) { this.element = element; this.tail = tail; public void setelement(t obj) { element = obj; public T getelement() { return element; public void settail(seq<? extends T> tail) { this.tail = tail; public Seq<? extends T> gettail() { return this.tail; public void sort(comparator<? super T> comp) {/*...*/ public String tostring() { return this.element.tostring() + (this.tail == null? "" : ", " + this.tail); //... Khalid Azim Mughal Java Brand Generics 21/40 Reference Declarations With Wildcards A wildcard can be used for declaration of references, but not for creating objects. Seq<? extends Number> numseq = new Seq<?>(2006, null); // Compile-time error The type of the object cannot be deduced. Such a reference can refer to an object whose type is a parameterized type in the set of invocations of the generic type denoted by the wildcard invocation. i.e. assignment compatibility is according to the variant parametric type hierarchy of the wildcard instantiations. Seq<Integer> intseq = new Seq<Integer>(10, null); Seq<Number> numseqc = new Seq<Number>(50.5, intseq); //Seq<Number> numseqd = intseq; // Compile-time error Seq<? extends Number> numseqe = intseq; Seq<? extends Integer> numseqf = null; Seq<? super Integer> numseqg = new Seq<Integer>(2004, null); See class Seq<T> for examples of wildcards in reference declarations, formal method parameters and method return types. Declaring references with wildcards is analogous to declaring references of interface types, as interfaces cannot be instantiated. Khalid Azim Mughal Java Brand Generics 22/40

12 Access Restrictions on References declared with <?> Seq<Integer> intseq = new Seq<Integer>(2005, null); Seq<?> seq = new Seq<Integer>(2006, intseq); // (1) // seq.setelement(new Integer(2007)); // (2) Compile-time error // seq.settail(intseq); // (3) Compile-time error seq.settail(null); // (4) Object ref = seq.getelement(); // (5) seq = seq.gettail(); // (6) String str = seq.tostring(); // (7) Not ok to write, except nulls. Cannot call a method that has a formal parameter whose type cannot be determined from the actual type parameter (in this case <?>), i.e. it is some unknown type. Ok to read Objects. For example, can call a method whose result type is determined to be an unknown type, as it will always be some Object. Khalid Azim Mughal Java Brand Generics 23/40 Access Restrictions on References declared with <? extends T> Seq<Integer> intseq = new Seq<Integer>(2005, null); Seq<? extends Number> numseq = new Seq<Integer>(2006, intseq); // (1) // numseq.setelement(new Integer(2007)); // (2) Compile-time error // numseq.settail(intseq); // (3) Compile-time error numseq.settail(null); // (4) Number ref = numseq.getelement(); // (5) numseq = numseq.gettail(); // (6) String str2 = numseq.tostring(); // (7) Not ok to write, except null. Cannot call a method that has a formal parameter whose type cannot be determined from the actual type parameter (in this case <? extends Number>), i.e. it is some unknown subtype of Number. Ok to read Numbers. For example, can call a method whose result type is determined to be the upper bound of the wildcard. Khalid Azim Mughal Java Brand Generics 24/40

13 Access Restrictions on References declared with <? super T> Seq<Integer> intseq = new Seq<Integer>(2005, null); Seq<? super Integer> seq = new Seq<Integer>(2006, intseq); // (1) seq.setelement(new Integer(2007)); // (2) // seq.settail(intseq); // (3) Compile-time error seq.settail(null); // (4) Object ref = seq.getelement(); // (5) // seq = seq.gettail(); // (6) Compile-time error String str = seq.tostring(); // (7) Ok to write Integers. Safe to write for lower bound. Ok only to read Objects. Not safe to assume any other type but Object. Khalid Azim Mughal Java Brand Generics 25/40 Flexibility with Wildcard Type Parameters Consider the following two implementations of the sort() method for the generic class Seq<T>: public void sort(comparator<t> comp) {/*...*/ // Alt. (1) public void sort(comparator<? super T> comp) {/*...*/ // Alt. (2) Client code: Seq<String> strseq = new Seq<String>("aha", new Seq<String>("aho", null)); strseq.sort(string.case_insensitive_order); // Comparator<String> is ok for (1) // and (2). strseq.sort(new Comparator<Object>() { // Comparator<Object> is not ok public int compare(object o1, Object o2) // for (1) and but is ok for (2). {return...; ); Alt. 2 gives greater flexibility in choice of comparator. Khalid Azim Mughal Java Brand Generics 26/40

14 Type Parameters with Multiple Bounds A type parameter T can have multiple bounds: T extends MyClass & Comparable<T> & Serializable Example of usage: class SomeClass<T extends MyClass & Comparable<T> & Serializable> { /*...*/ If the raw type of a bound is a superclass, then it can only be specified as the first bound and there can only be one such bound (as a subclass can only extend one immediate superclass). A type parameter T having multiple bounds is a subtype of all of the types denoted by the individual bounds. The raw type of an individual bound cannot be used with different arguments: E extends Object & Comparable<E> & Serializable & Comparable<String> // Not OK. The first bound is used as the type erasure for the type parameter T (see discussion on type erasures). Note the use of the type parameter T in the bound Comparable<T>. In the invocation SomeClass<MyType>, the compiler ensures that MyType also implements Comparable<MyType>. Khalid Azim Mughal Java Brand Generics 27/40 Type Parameters within Bounds class Foo<E extends Comparable> { Foo<Comparable> compref = new Foo<Integer>(); // (1) Not Ok Foo<? super Number> numref = null; // (2) Not within bound! numref = new Foo<Integer>(); // (3) Not ok Foo<? super Integer> intref = new Foo<Integer>(); // (4) Ok Foo<? extends Integer> intref2 = new Foo<Integer>(); // (5) 0k In (2), the parameterized type Foo<? super Number> is the set of all invocations for any type that is a supertype of Number and a subtype of Comparable. There is no such type. In (4), the parameterized type Foo<? super Integer> is the set of all invocations for any type that is a supertype of Integer and a subtype of Comparable. Integer and Comparable are such types. In (5), the parameterized type Foo<? extends Integer> is the set of all invocations for any type that is a subtype of Integer and a subtype of Comparable. Integer is such a type. Khalid Azim Mughal Java Brand Generics 28/40

15 Generic Interfaces Specification of a generic interface is analogous to that of a generic class: public interface Comparable<E> { int compareto(e thingy); Invocation of a generic interface is analogous to that of a generic class, but it is done in conjunction with a class implementing the interface: // Non-generic class implements generic interface class Node implements Comparable<Node> { //... int compareto(node thingy) {... //... // Generic class implements generic interface public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable { //... Khalid Azim Mughal Java Brand Generics 29/40 GENERIC METHODS Declaring Generic Methods Calling Generic Methods Limitations on Generic Methods and Wild Card Usage Khalid Azim Mughal Java Brand Generics 30/40

16 Declaring Generic Methods A generic method (a.k.a. polymorphic method) is implemented like an ordinary method, except that a type parameter is specified immediately preceding the return type. Examples: Two attempts at writing a generic method that returns the "maximum" of two objects. static <T> T max1(t obj1, T obj2) { // Note the type parameter. T result = obj1; if (obj1.compareto(obj2) < 0) // Compiler-time error: method compareto(t) not found result = obj2; return result; static <T extends Comparable<T>> T max2(t obj1, T obj2) { T result = obj1; if (obj1.compareto(obj2) < 0) // OK result = obj2; return result; A generic method need not be in a generic class. If declared in a generic class, a generic method can also use the type parameters of the class. Khalid Azim Mughal Java Brand Generics 31/40 Calling Generic Methods A generic method can be called like an ordinary method, without any actual type parameter. The parameter type (and the return type) is inferred from the type of the actual parameters. int maxint = max2(12,23); // OK String maxstr = max2("aha", "madonna"); // OK Number numresult= max2(new Integer(12), new Double(23.0)); // Compile-time error Calling generic methods whose parameters have parameterized types. // Generic Methods: static <T> void merge1 (Seq<T> s1, Seq<T> s2) { /*...*/ ; static <T> void merge2 (Seq<T> s1, Seq<? extends T> s2) { /*...*/ ; static <T> void merge3 (Seq<T> s1, Seq<? super T> s2) { /*...*/ ; // Client code: Seq<Number> numseq = new Seq<Number>(31.4, null); Seq<Integer> intseq = new Seq<Integer>(2004, null); // merge1(numseq, intseq); // Compile-time error merge2(numseq, intseq); // OK, T is Number // merge2(intseq, numseq); // Compile-time error merge3(intseq, numseq); // OK, T is Integer // merge3(numseq, intseq); // Compile-time error Khalid Azim Mughal Java Brand Generics 32/40

17 Generic Methods and Wildcards Dependency between the type of the parameter obj and that of the element type of the collection c is not captured by the wildcard <?> in this nongeneric method: static boolean add (Object obj, Collection<?> c) { return c.add(obj); // Compile-time error: // Cannot add to a collection of unknown type Dependency between the type of the parameter obj and that of the element type of the collection c is captured by the type parameter in this generic method. static <T> boolean add (T obj, Collection<T> c) { return c.add(obj); // OK Khalid Azim Mughal Java Brand Generics 33/40 TRANSLATION BY TYPE ERASURE Translating Type Parameters, Wildcards and Generic Methods Mixing Generic Types and Raw Types Khalid Azim Mughal Java Brand Generics 34/40

18 Post-Erasure Code for the Generic Class Seq<T> Note how the type parameter has been erased and all usage of the type parameter replaced by the type Object. public class Seq { private Object element; private Seq tail; Seq(Object obj, Seq seq) { element = obj; tail = seq; public void setelement(object obj) { element = obj; public Object getelement() { return element; public void settail(seq seq) { tail = seq; public Seq gettail() { return tail; public String tostring() { return... //... A tool like jad can be used to decompile the class files to see the post-erasure code ( Khalid Azim Mughal Java Brand Generics 35/40 Example of Post-Erasure Code for Overriding Bridge methods are inserted in subclasses to ensure that overriding works correctly. public class Age implements Comparable<Age> { int age; Age(int age) { this.age = age; public int compareto(age that) { return this.age - that.age; public class Age implements Comparable { int age; Age(int age) { this.age = age; public int compareto(age that) { return this.age - that.age; public int compareto(object obj){ return compareto((age)obj); Khalid Azim Mughal Java Brand Generics 36/40

19 Mixing Raw Types and Generic Types For backward compatibility, use of the raw type of a generic type is allowed, i.e. a generic type can be used without its type parameters. Assignments from raw types to parameterized types generate a warning, as in (2). Using raw type references to call methods whose signature uses type parameters generates a warning, as in (5). Note the ClassCastException in (6) at runtime because of the method call in (5). import java.util.*; public class Legacy { public static void main(string[] args) { List<String> strlist = new ArrayList<String>(); // (0) List list = strlist; // (1) Assignment to nongeneric reference is ok. strlist = list; // (2) warning: unchecked assignment strlist.add("aha"); // (3) Method call typesafe. // strlist.add(23); // (4) Compile-time error list.add(23); // (5) warning: [unchecked] unchecked call to add(e) // as a member of the raw type java.util.list System.out.println(strList.get(1).length()); // (6) ClassCastException Khalid Azim Mughal Java Brand Generics 37/40 Post-Erasure Code for the class Legacy It is instructive to compare the corresponding lines of code in the pre-erasure and post-erasure versions of the class Legacy. Note the cast inserted to convert from Object type to String type in (6'). public class Legacy { //... public static void main(string[] args) { ArrayList strlist = new ArrayList(); // (0') ArrayList list = strlist; // (1') strlist = list; // (2') strlist.add("aha"); // (3') list.add(integer.valueof(23)); // (5') System.out.println(((String)strList.get(1)).length()); // (6') Khalid Azim Mughal Java Brand Generics 38/40

20 OTHER IMPLICATIONS AND RESTRICTIONS REGARDING JAVA GENERICS A type parameter cannot be referenced in a static context. Runtime type check with instanceof and casting on generic types have no meaning. Arrays of generic types are not permitted. Foo<?>[] ref1 = new Foo<?>[10]; // OK Foo<Integer>[] ref2 = new Foo<?>[10]; // Declaration not ok Foo<? extends Number>[] ref3 = new Foo<Integer>[10]; // Not ok on both counts For overloading, it is not enough to use wildcards for formal parameter types. Generic classes can be extended: class Parent<A, B> { /*...*/ class Child<X, Y, Z> extends Parent<Z, Comparable> { /*...*/ The subclass provides the actual type parameters for the superclass. For overriding, the return type of the method in the subclass can now be identical or a subtype of the return type of the method in the superclass. A generic class cannot be a subclass of Throwable. Type parameters are allowed in the throws clause, but not for the parameter of the catch block. Varargs with a parameterized type are not legal. Khalid Azim Mughal Java Brand Generics 39/40 FURTHER STUDY AND RESOURCES 1. JSR 14 Add Generic Types To The Java Programming Language: Final Public Draft. ( 2. The Java Language Specification. JLS Maintenance Page at books/jls/jls-maintenance.html. 3. Gilad Bracha. Generics in the Java Programming Language, July ( java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf) 4. Gilad Bracha, Mads Torgersen. New Features in the Java Programming Language. JavaOne Conference, Session TS-3216, San Francisco, USA. June Mads Torgersen, Christian Plesner Hansen, Peter von der Ahé, Erik Ernst, Gilad Bracha, Neal Gafter. Adding Wildcards to the Java Programming Language. SAC 04 (ACM Symposium on Applied Computing), March 2004, Nicosia, Cyprus. Have generic fun! Khalid Azim Mughal Java Brand Generics 40/40