javac -source 1.4 Xyz.java

Patricia,

If the company or persons using the project has *no issue* in using JDK
1.5, I would go ahead and fix the type safety warnings because:

 1. a year or more later, the code will be easier to maintain.
 2. generics are generally a good idea that helps the programmer avoid
future type casting mistakes.  That's worth a lot.
 3. you may spot a yet undiscovered bug.

Cheers,
Missaka

Patricia Shanahan sez:

-Xlint:unchecked will shut 'em up, however,
there's a good chance you can simplify the code (and subsequent maintenance)
by getting rid of explicit casts and adding foreach loops,
unless you haven't learned anything in the last 12 months, you're sure to
find a few things in your code you'll want to improve. (Of course, whether
that's worth your time is another question.)

Dima

I would do something like the following:

First, characterize the warnings 1.5 adds to previously warning-free code.
Next, create a filter that removes them from the javac output, and use that
filter to compile your code.  If, at some future date, you want to start
using generics and will want to see the warnings, add a comment like

   /** No warnings in JDK 1.4 */

to the code you *won't* be genericizing, and filter results only for files
that don't contain that comment.  (Alternatively, make this a private field
instead of a comment, if your filter is written in Java and it's easier to
use reflection on the class file than to grep the source file.)

I can't offer alternative technical solutions.  I doubt if there are any
(though Mike's ingenious idea comes close).  Welcome to the wonderful world of
generics make-work !

Is it possible to split your stuff up so that you can compile some
sub-components with 1.4 settings, while continuing to work on other parts with
a 1.5 compiler ?

If not, or to the extent that is is not, then I think I'd just [sigh deeply
and] accept the hit.  Better to get it over with now, rather than having it
hanging around irritating me every time I think about it...  It'd be a chance
to do some code-cleaning too, so it might not be a /total/ waste of time.

This is what we get for using a language with a fashion-lead design process.

   -- chris

Whereas I like Chris's oh-so deep sighing, I would ask what's wrong with
sticking with 1.4? Are there particular features you require in 1.5 that
are not in 1.4?

1.4 is neither a second-best nor an out-dated version of the language
(older, yes, out-dated, no). Generics-lovers will flap hands, roll eyes,
mince around, and squeal, "But it's sssssssssssssooooooooo type-unsafe!"
If you're constantly getting ClassCastExceptions because you're
repeatedly pulling the wrong class from your collections, then move to
1.5 and generics-up; but if you've programmed in Java for more than 6
months, you'll probably get one of those exceptions per year, and it'll
take you somewhere in the region of ... oh, say five seconds to correct it.

And what happens when Java 1.6 (ok, ok, Java 6) comes out? Will you
enter zombie-mode and slowly, awkwardly update all your code to be
1.6-specific (all the while moaning, "Brains ...")?

Oh, wait! Hang on! I forgot: in Java 1.5 you can use foreach. Forget
everything I said; upgrade to 1.5 and change all your for-loops to
foreaches. That'll make it all worthwhile!!

(And if you're wondering whether that's sarcasm, then you really do need
to upgrade to 1.5.)

(Sarcasm: 2, Common Sense: 0)

Can you show some of the statements that cause warnings?  We'll be in the
same state before long (code we don't want to touch that we'll be compiling
under 1.5) and I'd like to know what to watch out for.