#026 J2SE 5.0 Language Features Enhancements

As any Java programmer knows, you cannot put an int (or other primitive value) into a collection. Collections can only hold object references, so you have to box primitive values into the appropriate wrapper class (which is Integer in the case of int). When you take the object out of the collection, you get the Integer that you put in; if you need an int, you must unbox the Integer using the intValue method. All of this boxing and unboxing is a pain, and clutters up your code. The autoboxing and unboxing feature automates the process, eliminating the pain and the clutter.

The Autoboxing and Unboxing feature of J2SE 5.0 eliminates the drudgery of manual conversion between primitive types (such as int or long) and wrapper types (such as Integer or Long).

(1.1) Example without autoboxing

(1.2) Example with autoboxing

Summary

The enhanced For loop construct eliminates the drudgery and error-proneness of iterators and index variables when iterating over collections and arrays.

(2.1) Example wihtout using enhanced For loop

(2.2) Example with using enhanced For loop

Summary

In this lab exercise, you learned how to use the Enhanced For Loops of  J2SE 5.0.

Static import lets you avoid qualifying static members with class names without the shortcomings of the “Constant Interface antipattern.”

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects.
• Click Next.

• Under Name and Location pane, for the Project Name field, type in NotUsingStaticImport as project name.
• For Create Main Class field, type in testpackage.NotUsingStaticImport.
• Click Finish.

• Observe that NotUsingStaticImport project appears and IDE generated NotUsingStaticImport.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated NotUsingStaticImport.java as shown in Code-3.11 below.  Study the code by paying special attention to the bold fonted parts.

package testpackage; public class NotUsingStaticImport{ public static void main( String[] args ) { System.out.println( “Here are the attributes of a employee who will be hired: ” ); System.out.println( “Minimum Salary is: ” + EmpAttributes.MINSALARY ); System.out.println( “Maximum Salary is: ” + EmpAttributes.MAXSALARY ); System.out.println( “Max Vacation Days: ” + EmpAttributes.MAXVACATION ); System.out.println( “Max Raise Percentage: ” + EmpAttributes.MAXANNUALRAISEPERCENTAGE ); } }

Code-3.11:  NotUsingStaticImport.java

3. Write EmpAttributes.java under testpackage package.

package testpackage; public class EmpAttributes { public static final int MINSALARY = 50000; public static final int MAXSALARY = 70000; public static final int MAXVACATION = 15; public static final int MAXANNUALRAISEPERCENTAGE = 10; }

Code-3.12: EmpAttributes.java

4. Build and run the project

• Right click NotUsingStaticImport project and select Run Project.
• Observe the result in the Output window of the IDE. (Figure-3.13 below)

Here are the attributes of a employee who will be hired: Minimum Salary is: 50000 Maximum Salary is: 70000 Max Vacation Days: 15 Max Raise Percentage: 10

Figure-3.13: Result

(3.2) Example with using static imports

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects. Click Next.
• Under Name and Location pane, for the Project Name field, type in UsingStaticImport as project name.
• For Create Main Class field, type in testpackage.UsingStaticImport.
• Click Finish.

• Observe that UsingStaticImport project appears and IDE generated UsingStaticImport.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated UsingStaticImport.java as shown in Code-3.21 below.  Study the code by paying special attention to the bold fonted parts.

The static import construct allows unqualified access to static members without inheriting from the type containing the static members.  For example, you can say just MINSALARY instead of EmpAttribs.MINSALARY.

package testpackage; import static testpackage.EmpAttributes.*; public class UsingStaticImport { public static void main( String[] args ) { System.out.println( “Here are the attributes of a employee who will be hired: ” ); System.out.println( “Minimum Salary is: ” + MINSALARY ); System.out.println( “Maximum Salary is: ” + MAXSALARY ); System.out.println( “Max Vacation Days: ” + MAXVACATION ); System.out.println( “Max Raise Percentage: ” + MAXANNUALRAISEPERCENTAGE ); } }

Code-3.21:  UsingStaticImport.java

3. Write EmpAttributes.java under testpackage package.  This is the same code as you have written in the previous step.

package testpackage; public class EmpAttributes { public static final int MINSALARY = 50000; public static final int MAXSALARY = 70000; public static final int MAXVACATION = 15; public static final int MAXANNUALRAISEPERCENTAGE = 10; }

Code-3.12: EmpAttributes.java

4. Build and run the project

• Right click UsingStaticImport project and select Run Project.
• Observe the result in the Output window of the IDE. (Figure-3.23 below)

Here are the attributes of a employee who will be hired: Minimum Salary is: 50000 Maximum Salary is: 70000 Max Vacation Days: 15 Max Raise Percentage: 10

Figure-3.23: Result

In this lab exercise, you learned how to use the Static import of  J2SE 5.0.

In past releases, a method that took an arbitrary number of values required you to create an array and put the values into the array prior to invoking the method. For example, here is how one used the MessageFormat class to format a message:

Object[] arguments = { new Integer(7), new Date(), “a disturbance in the Force” }; String result = MessageFormat.format( “At {1,time} on {1,date}, there was {2} on planet ” + “{0,number,integer}.”, arguments);   // arguments is an array

It is still true that multiple arguments must be passed in an array, but the varargs feature automates and hides the process. Furthermore, it is upward compatible with preexisting APIs. So, for example, the MessageFormat.format method now has this declaration:

public static String format(String pattern, Object… arguments);

The three periods after the final parameter’s type indicate that the final argument may be passed as an array or as a sequence of arguments.  Varargs can be used only in the final argument position. Given the new varargs declaration for MessageFormat.format, the above invocation may be replaced by the following shorter and sweeter invocation:

String result = MessageFormat.format( “At {1,time} on {1,date}, there was {2} on planet ” + “{0,number,integer}.”, 7, new Date(), “a disturbance in the Force”); // varargs

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects. Click Next.
• Under Name and Location pane, for the Project Name field, type in NotUsingVarArgs as project name.
• For Create Main Class field, type in NotUsingVarArgs.
• Click Finish.

• Observe that NotUsingVarArgs project appears and IDE generated NotUsingVarArgs.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated NotUsingVarArgs.java as shown in Code-4.11 below.  Study the code by paying special attention to the bold fonted parts.

import java.util.Date; import java.text.MessageFormat; import java.util.*; public class NotUsingVarArgs { public String formatThis() { Object[] args = { “Hurricane”, new Integer( 99 ), new GregorianCalendar( 1999, 0, 1).getTime(), new Double( 10E7 )     }; return MessageFormat.format( “On {2}, a {0} destroyed {1} houses and caused {3} of damage”, args ); } public static void main( String[] args ) { NotUsingVarArgs v = new NotUsingVarArgs(); System.out.println( v.formatThis()); } }

Code-4.11:  NotUsingVarArgs.java

3. Build and run the project

• Right click NotUsingVarArgs project and select Run Project.
• Observe the result in the Output window of the IDE. (Figure-4.13 below)

On 1/1/99 12:00 AM, a Hurricane destroyed 99 houses and caused 100,000,000 of damage

Figure-4.13: Result

1. Create a new NetBeans project

• Select File->New Project (Ctrl+Shift+N). The New Project dialog box appears.
• Under Choose Project pane, select Java under Categories and Java Application under Projects.
• Click Next.

• Under Name and Location pane, for the Project Name field, type in UsingVarArgs as project name.
• For Create Main Class field, type in UsingVarArgs.
• Click Finish.

• Observe that UsingVarArgs project appears and IDE generated UsingVarArgs.java is displayed in the source editor window of NetBeans IDE.

2. Modify the IDE generated UsingVarArgs.java as shown in Code-4.21 below.  Study the code by paying special attention to the bold fonted parts.

import java.util.Date; import java.text.MessageFormat; import java.util.*; public class UsingVarArgs { public UsingVarArgs() { } public String formatThis() { return( MessageFormat.format( “On {2}, a {0} destroyed {1} houses and caused {3} of damage”, “Hurricane”, new Integer( 99 ), new GregorianCalendar( 1999, 0, 1).getTime(), new Double( 10E7 ) ) ); } public static void main( String[] args ) { UsingVarArgs v = new UsingVarArgs(); System.out.println( v.formatThis()); } }

Code-4.21:  UsingAutoBoxging.java

3. Build and run the project

• Right click UsingVarArgs project and select Run Project.
• Observe the result in the Output window of the IDE. (Figure-4.23 below)

On 1/1/99 12:00 AM, a Hurricane destroyed 99 houses and caused 100,000,000 of damage

Figure-4.23: Result

In this lab exercise, you learned how to use the variable arguments feature of the  J2SE 5.0.

In pre-J2SE 5.0, the standard way to represent an enumerated type was the “int Enum pattern” as following:

// int Enum Pattern – has severe problems! public static final int SEASON_WINTER = 0; public static final int SEASON_SPRING = 1; public static final int SEASON_SUMMER = 2; public static final int SEASON_FALL   = 3;

This pattern has several problems as following:

• Not typesafe – Since a season is just an int type, you can pass in any other int value where a season is required, or add two seasons together (which makes no sense).
• No namespace – You must prefix constants of an “int enum” with a string (in this case SEASON_) to avoid collisions with other int enum types.
• Brittleness – Because int enums are compile-time constants, they are compiled into an application that use them. If a new constant is added between two existing constants or the order is changed, the application must be recompiled. If it is not, it will still run, but its behavior will be undefined.
• Printed values are uninformative – Because they are just ints, if you print one out, all you get is a number, which tells you nothing about what it represents, or even what type it is.

It is possible to get around these problems by using the Typesafe Enum pattern (see Effective Java Item 21), but this pattern has its own problems: It is quite verbose, hence error prone, and its enum constants cannot be used in switch statements.

Type-safe Enumeration (enum) allows you to create enumerated types with arbitrary methods and fields. It provides all the benefits of the Typesafe Enum pattern (“Effective Java”, Item 21) without the verbosity and the error-proneness.

(5.1) Example “without” using Type-safe enumerations

(5.2) Example “with” using type-safe enumerations

Summary