Java Tip 5: Java constants

Create constants that have the benefits of
using the C preprocessor's facilities

This week we create some constants that have all of the benefits of using the C preprocessor's facilities to define compile-time constants and conditionally compiled code.

Java has gotten rid of the entire notion of a textual preprocessor (if you take Java as a "descendent" of C/C++). We can, however, get the best benefits of at least some of the C preprocessor's features in Java: constants and conditional compilation.

One of the inarguably good features of the C preprocessor is the ability to define compile-time constants using a textual name to represent some value. This makes it easier to read and maintain. It is also faster at runtime than using a normal variable.

An arguably abused feature of the C preprocessor is the use of #define along with #ifdef and friends to conditionally compile entire blocks of code. I say it's arguable since people often use this facility to deal with platform-specific issues (and that's both the good point and the bad point).

In C, one could define some constants in a header file via:

#define MY_BDATE    10
#define     SILLY_PLATFORM

and then getting access to those constants by using #include to include them in a code file, and then using them:

fprintf (stderr, "My birthday is on the %d" "th!\n", MY_BDATE);

The equivalent in Java can be done by creating public static final variables in a Java interface:

interface ConstantStuff
    public static final int MY_BDATE = 10;
    public static final boolean SillyPlatform = true;

Then we can access them by using import to make the interface visible to us and then using the constants:

System.out.println ("My birthday is on the " + ConstantStuff.MY_BDATE + "th!");

The C preprocessor can conditionally strip out large areas of text if a given preprocessor constant was or was not defined.

#if defined(SILLY_PLATFORM)
/* Lot's of nasty code to deal with the stupidities of the
 * SILLY platform.
/* Code to deal with other, normal platforms. */

Many folks lament that this capability is absent from Java. Remember, one of the reasons that Java is so wonderful is that the language is so much better defined, so system-specific code like that should not even be necessary.

Be that as it may, you can still get that sort of conditionally compiled code from the compiler directly! You just use public static final boolean constants as the condition for a regular if statement. The Java compiler is smart enough to recognize that as a special case and it can completely eliminate the test and the code of the appropriate conditional branch.

So just write the conditional statement as usual.

    if (ConstantStuff.SillyPlatform)
        // Code to be used if platform is true *at compile time*.
        // Code to be use if platform is false *at compile time*.

I don't know about you, but I hate having to write that long-winded interface name before using any of those constants. So, I just have my class that is going to use those constants implement the interface. Then I can just use the name directly, assuming there are no name clashes (in which case you'll have to distinguish them using the full names).

I've put all of these fun things together in a couple of simple Java applications. Constants ( implements the interface and uses the constants directly while Constants2 ( uses fully qualified names to access the constants.

John D. Mitchell is yet another UC-Berkeley Computer Science graduate weaned on caffeine, sugar, and way too little sleep. He spent three years toiling on PDA software at Geoworks for stock that is actually worth more than wallpaper. He bailed out of his day job after the first public release of Java to develop applets and a Java compiler. He funds his Java addiction by writing compilers, Tcl/Tk, Perl, C++, and Java systems. His copious spare time is consumed by moderating the comp.lang.tcl.announce newsgroup and writing an awesome Java book.