DrStrangebrac<E,T> Or how I learned to stop worrying, and love generics...

Transcription

1 DrStrangebrac<E,T> Or how I learned to stop worrying, and love generics... a presentation to The Seattle Java Users Group by Wilhelm Fizpatrick Java is Sun Microsystems, all other trademarks are the property of their owners

2 Java a few changes Significance Annotations Generics Autoboxing Varargs Enhanced for Loop Enumerations Static Imports Intrusiveness Generics Autoboxing Varargs Enumerations Annotations Enhanced for Loop Static Imports The first major change to the language since 1.1 (who remembers assert?)

3 Generics: Significantly Intrusive Already in use in the standard libraries 41 classes and 19 interfaces are now generic (out of 3500) In java.lang, java.lang.reflect, java.lang. ref, java.util, java.util.concurrent, java. security, javax.naming Being retrofitted onto many extension APIs Hard to say I ll ignore them for now

4 public static <T extends Object & Comparable<? super T>> T What s Going On Here?!? max(collection<? extends T> coll) [Generics are] the most monstrously conceived and dangerous communist plot we have ever had to face General Jack D. Ripper (paraphrased) We had a nice cosy little language going, and somebody snuck in and added all these angle brackets to it! Do we need them? They are not only possible, they are essential! Dr. Strangebrac<E,T>

5 Don t Panic! Survival Kit Strange syntax in the JavaDoc? Ignore everything between the <angle brackets> Read single capital letters (E, T, K, V) as Object For example: public static <T extends Object & Comparable<? super T>> T max(collection<? extends T> coll) can be read as public static Object max(collection coll)

6 Survival Kit Ignore the unchecked warning: Note: Test.java uses unchecked or unsafe operations. Note: Recompile with -Xlint:unchecked for details. Disable it if you like: javac -Xlint:-unchecked MyCode.java Live life much as you always did...

7 Business As Usual public class Business { public static void main( String[] args ) { List l = new ArrayList(); l.add( "foo" ); l.add( "qux" ); l.add( "bar" ); System.out.println(Collections.max( l )); } } $ javac Business.java Note: Business.java uses unchecked or unsafe operations. Note: Recompile with -Xlint:unchecked for details. $ java Business qux

8 Questions?

9 What are Generics Anyway? Generic programming is a distinct approach to program design, on a par with procedural, object-oriented, or functional approaches "My working definition of generic programming is "programming with concepts," where a concept is defined as a family of abstractions that are all related by a common set of requirements." David R. Musser, generic programming researcher "Generic programming is a programming method that is based in finding the most abstract representations of efficient algorithms." Alexander Stepanov, C++ STL Author Generic programming focuses on describing algorithms independent of the type of data on which they operate

10 Why Not Use Assembly? Back when programmers coded to the metal, we didn t talk about types we just operated on the data Sounds perfect for generic programming! But what happens when you perform the right operation on the wrong data? We d like our language to catch these things

11 Type Checking Static Type Checking At compile time, based on information in the source C++, Pascal, Haskell Dynamic Type Checking While the program runs, by tagging data elements with their type Python, Ruby, Scheme

12 Java: static or dynamic? Both! The compiler performs type checking, but The programmer can override the compiler, so The runtime also performs type checking The compiler and the runtime each detect problems the other cannot

13 Java s Static Type Checking Statically detected type errors Are found sooner at compile time Won t crash a running program But... We have to help the compiler by declaring our types The compiler can t help us if we keep our data in generic variables: Object o = "10/19/2004"; ((Date)o).getYear();

14 Who Does That? Us, every day... We just disguise it better: Set appointments = new HashSet(); appointments.add( "10/19/2004" );... Iterator i = appointments.iterator(); ((Date)i.next()).getYear(); This is called the generic idiom (when we get it right)

15 Java Generics Java generics are an extension of Java s static type checking system Generic types exist only at compile time, they have no existence at runtime They allow us to be more confident in our use of the generic idiom

16 Improved Survival Kit Learn enough about those angle brackets and capital letters to understand what the JavaDoc is trying to tell you Declare and use parameterized types from the standard library Strive to eliminate unchecked warnings Compile with -Xlint:unchecked

17 Unchecked Warnings An unchecked warning means the compiler can t prove your code is typesafe... $ javac -Xlint:unchecked Business.java Business.java:7: warning: [unchecked] unchecked call to add(e) as a member of the raw type java.util.list l.add( "foo" ); ^ Business.java:8: warning: [unchecked] unchecked call to add(e) as a member of the raw type java.util.list l.add( "qux" ); ^ Business.java:9: warning: [unchecked] unchecked call to add(e) as a member of the raw type java.util.list l.add( "bar" ); ^...

18 Unchecked Warnings... ^ Business.java:10: warning: [unchecked] unchecked conversion found : java.util.list required: java.util.collection<? extends T> System.out.println(Collections.max( l )); ^ Business.java:10: warning: [unchecked] unchecked method invocation: <T>max(java.util.Collection<? extends T>) in java.util.collections is applied to (java.util.list) System.out.println(Collections.max( l )); ^ 5 warnings The compiler doesn t have enough information But it still must compile old code

19 Type Safety (according to Java) If a program compiles with no errors or warnings Then it will produce no unexpected type errors at runtime (ClassCastException) When is a type error expected? When the programmer explicitly overrides the compiler (inserts an cast)

20 Help the Compiler Help You To give the compiler the information it needs, we must talk about types abstractly To talk about data abstractly, we use parameters: int add( int a, int b ) { return a + b } Then we bind them to concrete values: add( 3, 6 )

21 Type Variables So let s do the same for types declare: interface Map<K,V> { void put( K key, V value ); V get( K key ); } And bind: Map<String,Date> appointments =... interface Map<String,Date> { void put( String key, Date value ); Date get( String key ); }

22 Naming Conventions A type variable can be any Java identifier But a single capital letter is preferred E for elements of a collection K and V for keys and values T, U, and V for types with no specific semantics Probably at most two or three per class

23 Terminology Alert When we say Map<String,Date> We are said to have instantiated a generic (also known as a parameterized) type But a type instance only exists at compile time Object instantiation and type instantiation are two different concepts with the same name!

24 New Business public class Business { public static void main( String[] args ) { List<String> l = new ArrayList<String>(); l.add( "foo" ); l.add( "qux" ); l.add( "bar" ); System.out.println(Collections.max( l )); } } $ javac -Xlint:unchecked Business.java $ java Business qux

25 What s New is Old Again $ javap -c Business Compiled from "Business.java" public class Business extends java.lang.object{... public static void main(java.lang.string[]); Code: 0: new #2; //class java/util/arraylist 3: dup 4: invokespecial #3; //Method java/util/arraylist."<init>":()v 7: astore_1 8: aload_1 9: ldc #4; //String foo 11: invokeinterface #5, 2; //InterfaceMethod java/util/list.add:(ljava/lang/object;)z... 38: aload_1 39: invokestatic #9; //Method java/util/collections.max:(ljava/util/collection;)ljava/lang/object; 42: checkcast #10; //class java/lang/string...

26 No Generics at Runtime Generic types are purely a feature of Java s static (compile time) type checking They are stripped away in the bytecode the fancy term for this is type erasure Thus, generic types can t be seen at runtime: List<Date> ld = new ArrayList<Date>(); List<String> ls = new ArrayList<String>(); System.out.println( ld.getclass() == ls.getclass() ); true

27 Why are Generic Collections a Good Thing? Type parameters act as documentation the compiler can act on: public void addnames( Set<String> names ); public Map<Date,Location> getappointments(); Fewer manual casts mean fewer mistakes: Date d = ld.get( 3 ); Arrays provide only one abstract data type, the list or sequence

28 Generics and Inheritance Will this compile? type inheritance applies List<Object> lo = new ArrayList<Date>(); Nope... no type inheritance RuntimeType.java:9: incompatible types found : java.util.arraylist<java.util.date> required: java.util.list<java.lang.object> List<Object> lo = new ArrayList<Date>(); Type parameters have no implicit super/sub type relationship

29 Why Not? Consider this: List<Date> ld = new ArrayList<Date>(); List<Object> od = ld; o1.add( "no typesafety today!" ); Date d = ld.get( 0 ); // Boom! Type safety would be violated Therefore the compiler doesn t allow it

30 Arrays Did It Differently Compiles fine... Date[] ad = new Date[5]; Object[] od = ad; od[0] = "type safety rides again!"; Date d = ad[0];...but at runtime: Exception in thread "main" java.lang.arraystoreexception: java.lang.string at ArrayTest.main(ArrayTest.java:7) Generic types don t exist at runtime, so they cannot make the same bargain

31 Okay, Now What? public void printall( Collection<Object> os ) { for( Object o: os ) System.out.println( o ); } List<String> l = new ArrayList<String>(); l.add( "one" ); l.add( "two" ); printall( l ); $ javac -Xlint:unchecked Wildcard1.java Wildcard1.java:8: printall(java.util.collection<java.lang.object>) in Wildcard1 cannot be applied to (java.util.list<java.lang.string>) printall( l );

32 Alright, How About... public void printall( Collection os ) { for( Object o: os ) System.out.println( o ); } List<String> l = new ArrayList<String>(); l.add( "one" ); l.add( "two" ); printall( l ); $ javac -Xlint:unchecked Wildcard1.java $ java Wildcard1 one two

33 But Now We Can... public void printall( Collection os ) { for( Object o: os ) System.out.println( o ); os.add( new Date ); // poisoning the well } List<String> l = new ArrayList<String>(); l.add( "one" ); l.add( "two" ); printall( l ); $ javac -Xlint:unchecked Wildcard1.java Wildcard1.java:13: warning: [unchecked] unchecked call to add(e) as a member of the raw type java.util.collection os.add( new Date() ); 1 warning

34 And The Final Answer Is... public void printall( Collection<?> os ) { for( Object o: os ) System.out.println( o ); os.add( new Date ); // poisoning the well } List<String> l = new ArrayList<String>(); l.add( "one" ); l.add( "two" ); printall( l ); $ javac -Xlint:unchecked Wildcard1.java Wildcard1.java:13: add(capture of?) in java.util.collection <capture of?> cannot be applied to (java.util.date) os.add( new Date() ); 1 error

35 The Wildcard (?)? can be read as unknown type The compiler restricts what may be done with type variable bound to? List<?> l = new ArrayList<String>; It may be a return type (and is treated as Object) Object o = l.get(0); But not a method parameter type: l.add( foo ); //error

36 Object vs? Object is a concrete type that happens to be the root type in Java's type hierarchy It has meaning at both compile and run time? is the "unknown type" it can stand in for any type but the set of operations that can be performed with it are restricted? only has meaning at compile time

37 Collection<Object> vs Collection<?> vs Collection Collection<Object> is a collection of heterogeneous instances of potentially no common type Collection<?> is a collection of homogeneous instances of some common types we just don t know what that common type is Collection is a raw type unless we are dealing with legacy code, we should avoid it

38 A Problem With? interface Shape { void draw(); } class Circle implements Shape { public void draw() {} } void drawall( Collection<?> ss ) { for( Object s: ss ) s.draw(); } List<Circle> lc = new ArrayList<Circle>(); drawall( lc ); $ javac -Xlint:unchecked Shapes.java Shapes.java:20: cannot find symbol symbol : method draw() location: class java.lang.object for( Object s: ss ) s.draw();

39 Binding? interface Shape { void draw(); } class Circle implements Shape { public void draw() {} } void drawall( Collection<? extends Shape> ss ) { for( Shape s: ss ) s.draw(); } List<Circle> lc = new ArrayList<Circle>(); drawall( lc ); $ javac -Xlint:unchecked Shapes.java

40 Bound Wildcards <? extends Shape> can be read as any unknown subclass of Shape It s still an unknown type, so the compiler still prevents its use as a method parameter But the compiler does allow methods of Shape to be called on the unknown subclass There is also <? super Shape> which is any unknown superclass of Shape

41 Generic Methods Classes and interfaces are not the only things that can be parameterized Methods can also be parameterized we ve seen one already: Collections.max() Here s a simplified version of its signature: <T extends Comparable> T max( Collection<T> c ) parameter list (with bound!) return type parameterized argument type

42 Calling Generic Methods There is usually no need to bind the type parameters explicitly the compiler deduces them from context! String s = max( new ArrayList<String>() ); But the parameters can be bound explicitly if necessary: this.<string>max( new ArrayList<String>() ); Foo.<String>staticMax(new ArrayList<String>()); Must have a receiver!

43 Type Variable Scope The scope of a type variable on a class is the instance variables and methods of that class The scope of a type variable on a generic method is the body of that method Static methods can reference their own type variables, but not those of the enclosing class Static fields cannot use type variables

44 Scope Example class Demo<T> { T instv; T method1( T arg ) {} <T> method2( T arg1, T arg2 ) {} static void smethod1( T arg ) {} // no! static <T> int smethod2( T[] arg ) {} // yes! } static T statv; // no! The circled T s have no relationship to each other. In actual code, a different letter should be used for each one

45 Restrictions on Type Variables Cannot be bound to a primitive type Map<int,String> m; // not allowed Cannot be the target of new T create() { return new T(); } // nope Cannot be used to overload methods class MyClass<T,U> { void amethod(t) {...} void amethod(u) {...} }

46 No Generic Exceptions Exceptions cannot be parameterized class PException<T> extends Exception {... Because eventually you d want to } catch( PException<Date> ex ) {......but, generic types only exist at compile type, and thrown exceptions exist only at runtime, so that makes no sense!

47 No Runtime Type Checking Generic types cannot be used with instanceof if( t instanceof FutureTask<List<String>> ) {......because instanceof happens at runtime, but the generic type only exists at compile time Casting to a generic type produces an unchecked warning List<String> ls = (List<String>)foo.getList();...I ll bet you can guess why!

48 Arrays and Generics: Why can t we just get along? You can t create an array of generic types: new Map<String,String>[10]; // won t compile...although oddly you can declare a variable of that type Nor bind an array to a type parameter: Map<String,String[]> mas; // no mas! But you can check an array s compile time type via a type variable: <T> boolean contains( T[] a, T element ) {...

49 Java Generics vs C++ Templates As ever, Java borrowed C++ syntax and made it mean something very different Type erasure vs code generation Bounded type variables vs structural/latent/ duck typing (c2/eckel/thomas) Java generics are not a metaprogramming facility

50 Generic Objections Templates in C++ were too complicated Fair enough, but Java generics are implemented in a very different way, that avoids many of the pitfalls Java generics aren t as powerful as C++ templates Yes. See above...

51 Generic Objections Sun made bad implementation choices It s arguable many of the restrictions on generics are an attempt to preserve binary and source compatibility still, the result is a more expressive language I don t like the compiler doing stuff behind my back I'm sorry have you seen what try/finally or an inner class compiles to? Or even boolean not? Automatic casts are the least of your worries...

52 Resources Sun's Java Generics Tutorial Angelika Langer's Java Generics FAQ Draft Specification Final Specification The Java Language Specification, 3rd edition (not yet published!)