Yeh.  I think this is the hardest thing about java -- the build process.  
There are plenty of books explaing OOP theory, or books on ANT, but
little that I've found between the two.

Right now I'm actually using rake tasks (ruby) which is only mildly
awkward but easier for me to understand than ANT:

http://code.google.com/p/jrake/

Thanks :)

-Thufir

Ok, thanks, got it :)

Now, is it "crazy" or does it make sense to (sometimes) perform a
colossal build which would build all the different jar files in one go?  
Of course, theoretically, you don't need to do that, except:

In theory there is no difference between theory and practice. In practice
there is.
Yogi Berra

Just for reference, the (ruby) rake build file:

thufir@arrakis:~/jrake$
thufir@arrakis:~/jrake$ cat rakefile.rb
namespace :java do

       J_ROOT = "/home/thufir/jrake/"

       task :test => :package do
               puts "test"
               FileUtils.cd("#{J_ROOT}")
               FileUtils.cd("package")
               system("java -jar Foo.jar")
       end

       task :package => :jar do
               puts "package"
       end

       task :jar => :compile do
               puts "jar"
               FileUtils.cd("#{J_ROOT}")
               FileUtils.cd("prod")

               system("jar cfm #{J_ROOT}package/Foo.jar manifest.txt
thufir/foo/*.class")
               FileUtils.rm("manifest.txt")
       end

       task :create_manifest => :create_directories do
               puts "create_manifest"
               FileUtils.cd("#{J_ROOT}")
               FileUtils.cd("prod")

               File.open('manifest.txt', 'w') do |manifest|
                       manifest.puts "Main-Class: thufir.foo.Foo\n"
                       manifest.puts "Class-Path: #{J_ROOT}lib/thufir/
math/Calculations.jar\n"
               end
       end

       task :compile => :create_manifest do
               puts "compile"
               FileUtils.cd("#{J_ROOT}")
               FileUtils.cd("src")
               system("javac -d /home/thufir/jrake/prod/ -cp \"/home/
thufir/jrake/lib/thufir/math/Calculations.jar\" thufir/foo/Foo.java")
       end

       task :create_directories => :clobber do
               puts "create_directories"
               FileUtils.cd("#{J_ROOT}")
               FileUtils.mkdir("prod")
               FileUtils.mkdir("package")
       end

       task :clobber do
               puts "clobber"
               FileUtils.cd("#{J_ROOT}")
               FileUtils.rm_rf("prod")
               FileUtils.rm_rf("package")
       end

end
thufir@arrakis:~/jrake$

-Thufir

There is a rationale for it.  JARs are how you package your application to run
in a foreign environment (the user's).  You have no control over the user's
CLASSPATH or if they use the -cp option correctly.  To get around that, you
could write a shell script to launch the JAR, but that breaks portability, not
to mention you now have to deal with the PATH and all sorts of crap on the
user machine.  If you package your application as a JAR to be run with "java
-jar" it's independent of the client environment; the application packager has
complete control of the classpath.  Users cannot accidentally or maliciously
change things by substituting alternate classes into the classpath.  The
-classpath option is for the user; the -jar option with manifest control of
the classpath is for the vendor.

Perfectly "intuitive".