General Java

Digg This!

Page 2 of 2   « previous page

You could also use an interface for the same purpose. This is common, but it's debatable whether it's a good idea to do so.

This implementation has many problems. Since the constants are just ints, it's easy to pass out-of-range values to methods. There is nothing to prevent you from passing these constants to methods they weren't designed for.

For example:

public class Card {
	public Card (int suit, int rank) {
		...
	}
}

You can write something like new Card(KING,HEARTS) and you won't find out that something is wrong until runtime.

It's possible to use the "typesafe enum" pattern (for example, see the book Effective Java by Joshua Bloch) in JDK 1.4 to overcome these problems, but it requires a lot of boilerplate code, and the resulting classes have a fatal flaw, from the developer's point of view: you cannot switch on this kind of enum, so any switch-like code becomes very clunky.

J2SE introduces the enum keyword to specify first-class enumerated types. Here is simple example code:

public enum RegularPolygon {
		TRIANGLE, 
 		SQUARE, 
 		PENTAGON;
}

A significant advantage of the enum construct (compared to handcrafted enumerations) is that enums are full-fledged Java classes, so they can have constructors, fields, and methods. For example:

public enum RegularPolygon {
			TRIANGLE(3), 
   	SQUARE(4), 
   	PENTAGON(5);
	final int numSides;

	RegularPolygon (int sides) {
		numSides = sides;
	}
		public double perimeter (double sideLength) {
		return sideLength * numSides;
	}
}

Client code can switch on the enum:

public computeArea(RegularPolygon p, double side) {
	switch (p) {
		case Polygon.TRIANGLE:
			return side * side * Math.sqrt(3) / 4;
		case Polygon.SQUARE:
			return side * side;
		case Polygon.PENTAGON:
			return side * side * 1.72;
		default:
			System.err.println("Unknown polygon");
     return 0;
	}
}

The default case in the switch is used in case someone adds a new polygon to the enum.

Class Libraries
J2SE 5 introduces several utility classes that can make your life easier, but you obviously won't gain any benefits from them unless you actually use them. It is almost always a mistake to write your own implementation of a data structure or a method that is present in the Java class library. The base Java implementation is very likely to be better thought-out and less buggy than an implementation that you would come up with. Here are a few new additions to the Java class libraries that may prove useful.

Queue and Implementations
java.util.Queue is a new interface that has been added to the Collections framework. LinkedList now implements the Queue interface and models a simple FIFO queue. Another implementation you may find useful is PriorityQueue.

ProcessBuilder
The ProcessBuilder class provides a significantly easier way to launch and control applications than Runtime.exec() does. The following code will launch Eclipse on a Linux machine from a specified directory and display its window on the main display of the machine called italy.

String home = System.getProperty("user.home");
ProcessBuilder builder = new ProcessBuilder (
"./eclipse", "-data", home + "/workspace");
builder.directory(new File(home + "/eclipse"));
builder.environment().put("DISPLAY", "italy:0.0");
builder.start();

Formatter The Formatter class and its cousin methods String.format() and PrintStream.printf() provide a straightforward and powerful way to finely format strings and output. If you are familiar with the C printf and sprintf functions, it should be easy to use the new class and methods. For example, the following code will print out an amount of money using the correct padding if the cents are a one-digit number:

public static void dollarFormat (int dollars, int cents) {
	System.out.printf("$%d.%02d", dollars, cents);
}

Scanner
The Scanner class provides an easy way to extract strings and primitives from a formatted stream. By default, it uses white space for field delimiters, but it's easy to configure it to use any regular expression as a delimiter. J2SE 1.4 classes and methods such as StringTokenizer, String.split(), and Integer.parseInt() could cover some of the functionality that the Scanner class provides, but the new class is more flexible and powerful. The following code will echo lines from System.in to System.out, as long as they can be parsed as integers:

Scanner scanner = new Scanner(System.in);
scanner.useDelimiter(System.getProperty("line.separator"));
while (scanner.hasNextInt()) {
	System.out.println(scanner.nextInt());
}

Conclusion
Often, being a programmer is much like being a carpenter. To do a job well, you need to know which tools are available and which one is best suited for the job at hand. J2SE 5 provides a set of new tools that you can add to your Java development tool belt. Use them wisely, and you will spend more time thinking about how your code hangs together and less writing boilerplate and tracking down bugs.

References

• Bloch, J. (2001). Effective Java. Addison-Wesley.
• J2SE New Features: http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html
• Austin, C. (2004). "J2SE 5.0 in a Nutshell": http://java.sun.com/developer/technicalArticles/releases/j2se15/
• JSR 201 (Enumerations, Enhanced for loops, etc.): www.jcp.org/aboutJava/communityprocess/review/jsr201/
• JSR 14 (Generics): www.jcp.org/aboutJava/communityprocess/review/jsr14/

Page 2 of 2   « previous page