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
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:
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.
/* 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.
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).