Top Links You Must Click On
Java Developer's Journal: "Developing in Java 5"
How to use the new set of tools wisely
Jan. 8, 2005 03:45 PM
"Ease of Development" is one of the main focuses in J2SE 5. Accordingly, J2SE 5 introduces several new features designed to simplify the developer's life. If you use these new constructs, your code will become more compact and expressive, hence easier to understand and debug. This article explains how you can use the new features to prevent some silly mistakes, as well as some that are not so silly.
The main drawback of using this well-thought-out framework is that a significant amount of casting is required when extracting elements from a pre-J2SE 5 collection (because the collection necessarily has no knowledge of what kind of elements are stored in it). Listing 1 provides a simple example. In the listing, the line with the cast is clunky. Yet it seems that nothing could go wrong, since the only way to add elements to fileList is through the addFile method, which takes only a string.
However, problems will inevitably surface sooner or later. For instance, assume that two years later, you or another developer decide that it would be a good idea to store actual File objects (instead of their names) in the FileList class.
The addFile method will be changed to read:
The code will compile just fine. Yet, when the customer runs the application, it will crash with a ClassCastException as soon as the listExtensions () method is called. One way to guard against this problem is to wrap each casting operation into some defensive code:
This will solve the immediate problem, but it has several drawbacks:
J2SE 5 provides a solution for all of this: collections can now use generics. For instance:
private List <String> fileList = new ArrayList <String> ();
Now, only strings can be added to fileList, and method calls, such as fileList.get(0) and fileList.iterator().next(), will return strings with no casting necessary:
String name = it.next();
If you use generics and try to modify the addFile method, the compiler will flag your attempt to add a File to a List<String>. If you change the declaration of fileList to a List<File>, the compiler will now notice that it.next() returns File and not a string; this will force you to fix the listExtensions method.
Note that this is just one use of generics. One of my other favorites is that since the Comparable interface is now generic, you can write the following code and avoid the boilerplate instanceof/casting code that is common for compareTo method implementations:
Enhanced For Loop
Here is a snippet of buggy code (slightly modified from the J2SE 5 release notes):
If you try to run it, it will throw a NoSuchElementException. Can you spot the bug? The problem is that i.next() is being called every time a new card is created, rather than once per suit. As a result, we run out of suits much faster than expected. This is how to fix the loop:
J2SE 5's new enhanced for loop construct provides a neat solution for this. The nested loop in the above code can be rewritten as:
What appears to be happening is that the variables suit and rank point (in turn) to the elements of the Lists suits and ranks. Under the hood, the same code as in the fixed loop is being run.
Enhanced for loops can also be used while iterating through arrays. This time, instead of not having to explicitly iterate in your code, you can skip any references to the array indices:
As well as being more compact and easy to understand, the enhanced for construct for arrays prevents common bugs, such as referring to the wrong index in nested loops:
C has an enum construct, which in theory allows the developer to define an enumerated type, but in practice does little more than define a bunch of integer constants. In the pre-J2SE 5 world, the most common way to accomplish the same task was to mimic the way C works and write code like this:
Reader Feedback: Page 1 of 1
Enterprise Open Source Magazine Latest Stories . . .
Subscribe to the World's Most Powerful Newsletters
Subscribe to Our Rss Feeds & Get Your SYS-CON News Live!
SYS-CON Featured Whitepapers