New features in JDK 1.5 Can these new and complex features simplify Java development?

Overview Generic Types Auto-boxing/unboxing Enhanced For Loop Enumerations Variable Arguments Static Import Meta-data Formatted I/O Concurrency Utilities Management Utilities Class Data Sharing Loads of other improvements

Reasoning "The new language features all have one thing in common: they take some common idiom and provide linguistic support for it. In other words, they shift the responsibility for writing the boilerplate code from the programmer to the compiler." - Joshua Bloch, senior staff engineer, Sun Microsystems

Complementary Features Generics improve enhanced for loop Generics and auto-boxing/unboxing allow Enumerated types Variable args improve API usability Variable args allow formatted I/O

New features enhance existing API Generics enhance compile time type checking Generics improve reflection Generics allow return type overriding Enum improves readability and organization of constants Static import improves utility functions Auto-boxing improves readability

Generic Types interface Collection { boolean add(E o); boolean addAll(Collection c); Iterator iterator(); T[] toArray(T[] a); … }

Generic Interface (or Class) interface Collection … Collection integers; E is the type parameter for the generic type Collection is the raw type after type erasure Integer is the actual type parameter used when declaring an instance of the generic type Cannot use primitive types but auto-boxing covers over the difference

Using the Type Parameter boolean add(E o); Where ever E is used, the compiler will check the type against the actual type parameter. At runtime E will be Object.

Wildcard Parameters boolean addAll(Collection c); ? represents an unknown type List list = new ArrayList (); Not legal: List list = new ArrayList (); Would allow list.add( new Object() );

Bounded Type Parameters boolean addAll(Collection c); Constrains possible actual types An actual type must be same as E or extend E Can also constrain to implement multiple interfaces

Parameterized Methods T[] toArray(T[] a); Infers the actual type from the actual parameter passed to the method.

Type Erasure Insures backwards compatibility Avoids bloat ala C++ templates Type information still available through reflection

Small Example public static void main ( String... args ) { Collection strs = new ArrayList (); for ( String s : args ) strs.add( s ); Collection readonly = new ArrayList ( strs ); //readonly.add( "some string" ); Not allowed Collection copy = new ArrayList (strs); String[] strAry = strs.toArray( new String[] {} ); }

Auto-boxing/unboxing List ints = new ArrayList (); ints.add( 1 ); // auto-boxing to new Integer( 1 ) ints.add( 2 ); ints.add( 3 ); for ( int num : ints ) // Auto-unboxing using obj.intValue() System.out.println( num );

Enhanced for loop (foreach) Improves readability Reduces boilerplate code Works with both arrays and objects that expose an iterator

Enumerated Types Collects related constants into own namespace Codifies the type-safe enum idiom Can have constructors, fields and methods Can subclass Works well with switch statements Adds enum keyword to language. May require source changes before compiling with 1.5 compiler. Existing classes should still work.

Enum example enum Suit {clubs, diamonds, hearts, spades} enum Rank {deuce, three, four, five, six, seven, eight, nine, ten, jack, queen, king, ace} List deck = new ArrayList (); for (Suit suit : Suit.VALUES) for (Rank rank : Rank.VALUES) deck.add(new Card(suit, rank)); Collections.shuffle(deck);

Switch with Enum Color getColor( Suit suit ) { switch( suit ) { case clubs: case spades: return Color.Black; case diamonds: case hearts: return Color.Red; default: throw new AssertionError( suit + not valid value ); }

Variable Arguments String format( String format, Object... args ); format({2} {1}!, World, Hello); Nicer way to call a method that takes an array of some type Class…means Class[] inside of the method Use the enhanced for loop to iterate

Static Import import static java.lang.math.*; … int themax = max( , ); Reduces typing Alleviates need for implementing a Constant Interface Compiler error if names clash

Meta-data Available at compile-time or runtime with reflection Similar concept to XDoclet tags or.Net are standard

References Java Generics Tutorial J2SE 1.5 in a Nutshell A Conversation with Joshua Bloch What's new in J2SE David Flanagan Web log