Java 1.5

1. Java 1.5

2. Java 1.5.0 beta 1 (“Tiger”) • Released February 4, 2004 • http://java.sun.com/j2se/1.5/index.jsp • Themes • Ease of Development • Scalability and Performance • Monitoring and Manageability • Desktop Client • Miscellaneous Features • To use Java 1.5: • Download and install from http://java.sun.com/j2se/1.5.0/index.jsp • Use the -source 1.5 flag • Optionally, get: NetBeans 3.6, or... • ...get Eclipse 3.0 build M8 and the JDK 15. pluginhttp://eclipse-plugins.2y.net/eclipse/plugin_details.jsp?id=497

3. Generic types • Up through Java 1.4, collections hold arbitrary Objects • If you wanted, say, a Vector of Employees, you had two basic choices: • Use a Vector • Adding anEmployee is easy (but so is adding any otherObject, however inappropriate) • Getting an Employee from the Vector usually requires a cast, which may result in a runtime error • Extend Vector with an EmployeeVector class • Checking is done at compile time (which is better than runtime) • It’s a lot of extra work • Generic types do the second of these automatically for you • Syntax: Vector<Employee> employees = new Vector<Employee>();

4. An example • Instead of: • ArrayList list = new ArrayList();list.add(0, new Integer(42));int total = ((Integer)list.get(0)).intValue(); • You can say: • ArrayList<Integer> list = new ArrayList<Integer>();list.add(0, new Integer(42));int total = list.get(0).intValue(); • Advantages: • Less work to create specialized data structures • Checking done at compile time rather than runtime • For C++ programmers, the syntax is familiar • Disadvantage: • Yet more ugly syntax to learn

5. More generics • A lot of other things, besides collections, have been “genericized” in Java 1.5 • Parameterized Type • Vector<String> stringVector = new Vector<String> • List<Integer> integerList = new List<Integer> • Interface • interface List<Element> implements MyInterface{...} • Class • class MyList<Element> {...} • class MyList<Element> implements List<Element> {...} • Method • boolean containsBoth(Element a, Element b); • static <Element> boolean swap(List<Element> list, int i, int j);

6. Autoboxing • Up through Java 1.4, primitive types cannot be used where an object is required • They had to be wrapped, or boxed, for instance:myStack.push(new Integer(25)); • Primitive types still cannot be used where an object is required… • …But Java 1.5 now does this conversion automatically: • Now you can say myStack.push(25); • What happens at runtime is still the same • It’s just that the compiler does the conversion for you

7. Auto-unboxing • Just as you could not use primitive types where an Object was required, you could not use an Object where a primitive type was required • You had to do your own unwrapping, or un-boxing • For instance, you had to write code such as:int result = ((Integer)myStack.pop()).intValue(); • Now you can just write:int result = myStack.pop(); • Even more striking,myStack.push(new Integer(((Integer)myStack.pop()).intValue() + ((Integer)myStack.pop()).intValue()));becomesmyStack.push(myStack.pop() + myStack.pop());

8. Combining generics with autoboxing • Instead of: • ArrayList<Integer> list = new ArrayList<Integer>();list.add(0, new Integer(42));int total = list.get(0).intValue(); • You can say: • ArrayList<Integer> list = new ArrayList<Integer>();list.add(0, 42);int total = list.get(0); • Advantages: • Less code to write • Code becomes more readable

9. Auto [un]boxing disadvantages • Since more is hidden, it becomes harder to understand and explain what is going on • Equality is no longer transitive! Consider: • Integer a = new Integer(7);int b = 7;Integer c = new Integer(7); • if (a == b) … // will be trueif (b == c) … // will be trueif (a == c) … // will be false • For Objects, == is an identity test • This is a dangerous trap for the unwary

10. New for loop • Many collections in Java use Iterators • The new for loop automatically uses an Iterator • Example Java 1.4 code: • for (Iterator iter = employeeList.iterator(); iter.hasNext(); ) {Employee employee =(Employee)iter.next(); System.out.println(employee.getName());} • Example Java 1.5 code: • for (Employee employee : employeeList) { System.out.println(employee.getName());} • Advantage: • Convenient and fairly easy to read • Also works for iterators you define • Disadvantage: Stupid syntax (I wish they had used “in”)

11. Enumerated types • Enumerated types are a way of representing nonstandard data, such as days of the week, with integers: • static final int SUNDAY = 1;static final int MONDAY = 2;… • Or months of the year: • static final int JANUARY = 0;static final int FEBRUARY = 1;… • The problem with this approach is that there are so many ways to make errors: • static final int DECEMBER = 12; • int date = year + month + dayOfWeek; • Over the past few years there have been many attempts to define an idiom for making type-safe enumerations

12. Enumerated types in Java 1.5 • public enum Suit {clubs, diamonds, hearts, spades} • Notice new keyword “enum” • Values of enum constants are assigned automatically • public enum Coin{ • penny(1), nickel(5), dime(10), quarter(25); // values • Coin(int value) { this.value = value; } // constructor • private final int value; // instance variable • public int value() { return value; } // method • } • This is very like a class declaration • Printing results in the named constant: dime, not 10 • Named constants can be read in

13. Using an enumerated type • public class CoinTest { public static void main(String[] args) { for (Coin c : Coin.VALUES) System.out.println(c + ": \t" + c.value() +"¢ \t" + color(c)); } private enum CoinColor { copper, nickel, silver } private static CoinColor color(Coin c) { switch(c) { case Coin.penny: return CoinColor.copper; case Coin.nickel: return CoinColor.nickel; case Coin.dime: // deliberate fall through to next case case Coin.quarter: return CoinColor.silver; default: throw new AssertionError("Unknown coin: " + c); } }}

14. Advantages of enumerated types • enum types simplify code and make it more readable • Types are checked at compile time (hence, very type safe) • Performance is comparable to int constants • Each enum type has its own name space (you don't have to say Coin.dime) • You can add, reorder or even remove constants without the need to recompile other classes that use these constants • I’ve seen one source that says you do need to recompile • Printed values are informative • enum constants can be used in collections (for example, as HashMap keys) • You can add arbitrary fields and methods to an enum class • An enum type can be made to implement arbitrary interfaces • enum types can be used in switch statements • enum types are serializable

15. Disadvantages of enumerated types • Still more complexity in the language • Harder for beginners, nicer for experts!

16. The “Constant Interface” antipattern • public interface Physics { public static final double AVOGADROS_NUMBER = 6.02214199e23; public static final double BOLTZMANN_CONSTANT = 1.3806503e-23; public static final double ELECTRON_MASS = 9.10938188e-31;}public class Guacamole implements Physics { public static void main(String[] args) { double moles = ...; double molecules = AVOGADROS_NUMBER * moles; ... }} • This is considered to be very poor style by smart programmers who have thought about it a lot more than I have

17. Static import • You can now import just the static members of a class or interface • public interface Physics { // as before public static final double AVOGADROS_NUMBER = 6.02214199e23; public static final double BOLTZMANN_CONSTANT = 1.3806503e-23; public static final double ELECTRON_MASS = 9.10938188e-31;} • import static org.iso.Physics.*;class Guacamole { public static void main(String[] args) { double molecules = AVOGADROS_NUMBER * moles; ... }}

18. Metadata • Metadata lets you avoid writing boilerplate code, by enabling tools to generate it from annotations in the source code • This leads to a “declarative” programming style where the programmer says what should be done, and tools emit the code to do it • Details are tool-dependent, but the syntax involves the use of the @ sign • I have not yet seen any good, understandable examples

19. Varargs • If you want to pass a variable number of arguments to a method, you currently have to put them into an array • This is a lot of extra, messy code • Java 1.5 allows varargs—a variable number of arguments • Example:public String format(String pattern, Object... args) {...} • The ellipsis (...) after Objectis the new syntax • The varargs must be the very last thing in the parameter list • Within the method, args has type Object[ ] • No extra syntax is needed within the method—args is just an array • No new syntax is needed to call—just supply the parameters you want

20. Improved output • The new Formatter class, modeled after C’s printf statement, gives you much simpler formatted output • This class provides support for: • Layout justification and alignment • Common formats for numeric, string, and date/time data • Locale-specific output • Common Java types such as byte, BigDecimal, and Calendar • Limited formatting customization for arbitrary user types is provided through the Formattable interface

21. Improved input • The new Scanner class can parse primitive types and strings using regular expressions • The Scanner class can also read in input from a String (not just an I/O stream) • Thankfully, this class was not modeled after C’s scanf!

22. Other stuff • Lots of new classes and interfaces, such as Queue and PriorityQueue, MouseInfo • More “looks and feels:” Synth and Ocean • Enhancements to sound and image processing • Improvements in tools (javac, javadoc, JVMTI, JPDA) • Other improvements in networking, security, internationalization, etc. • Bug fixes (of course)

23. Final comments • As I said at the beginning of CIT591, the half-life of knowledge in computer science is about 5 years • You are well-prepared to learn Java 1.5, since it’s mostly “more of the same” • I expect to convert to Java 1.5 as soon as classes are over, and use it in the Fall

24. The End “Well, in our country,” said Alice, panting a little, “You’d generally get somewhere else if you ran very fast for a long time, as we’ve been doing.” “A slow sort of country!” said the Queen. “Now here, you see, it takes all the running you can do to keep in the same place. If you want to get somewhere else, you must run at least twice as fast as that!” —Lewis Carroll, Alice in Wonderland