For building you can export an Ant build file. Just right click on the project -> Export -> Ant buildfiles. On the command promt use ant <buildfile> to build the project.

Take a look at this answer: Eclipse: export running configuration for running the eclipse project from the console.

If you are using eclipse, compiling from the terminal is not needed, however you can do it like this:

Navigate to the project directory containing the .java files. You can then run javac ClassName.java e.g. javac Cake.java javac is the Java language compiler. This command will compile the source (your .java file). To run it you can go java ClassName. e.g. java Cake. java starts the JVM. The named class will be loaded and execution started. You don't include the .class file extension one the java ClassName command.

When you need you navigate around the file system I think this page gives a good overview of the commands but here are a few that you might need for this task:

cd - change directory (followed by directory name) e.g. cd Documents

ls - list information about files (can take some parameters)

.. can take you back a directory. e.g. cd .. will bump you back one directory

you can also hit tab to auto complete a directory/file name.

You will need to go to Project->Clean...,then build your project. This will work, even when your source code does not contain any main method to run as an executable program. The .class files will appear in the bin folder of your project, in your workspace.

You can run Java applications from the command line. The simplified syntax looks like this:

java -cp <classpath> <main class> <args>

where:

<classpath> - list of directories and/or JAR-files where needed classes reside separated by ";" for Windows or ":" for linux (default classpath is "." - the current directory);

<main class> - fully qualified name of the class containig main() method (for example, org.myself.HelloWorld)

<args> - various arguments for application if any.

So, if you find the directory where Eclipse stored compiled classes (usually it's bin) you may use the command, like

java -cp . my.package.MyClass

Or, if you use some libraries and classes in other directories, it could be:

java -cp some-cool-lib.jar:another-lib.jar:/some/directory/with/classes my.package.MyClass

To complete André's answer, an ant solution could be like the one described in Emacs, JDEE, Ant, and the Eclipse Java Compiler, as in:

      <javac
          srcdir="${src}"
          destdir="${build.dir}/classes"> 
        <compilerarg 
           compiler="org.eclipse.jdt.core.JDTCompilerAdapter" 
           line="-warn:+unused -Xemacs"/>
        <classpath refid="compile.classpath" />
      </javac>

The compilerarg element also allows you to pass in additional command line args to the eclipse compiler.

You can find a full ant script example here which would be invoked in a command line with:

java -cp C:/eclipse-SDK-3.4-win32/eclipse/plugins/org.eclipse.equinox.launcher_1.0.100.v20080509-1800.jar org.eclipse.core.launcher.Main -data "C:\Documents and Settings\Administrator\workspace" -application org.eclipse.ant.core.antRunner -buildfile build.xml -verbose

BUT all that involves ant, which is not what Keith is after.

For a batch compilation, please refer to Compiling Java code, especially the section "Using the batch compiler"

The batch compiler class is located in the JDT Core plug-in. The name of the class is org.eclipse.jdt.compiler.batch.BatchCompiler. It is packaged into plugins/org.eclipse.jdt.core_3.4.0..jar. Since 3.2, it is also available as a separate download. The name of the file is ecj.jar.
Since 3.3, this jar also contains the support for jsr199 (Compiler API) and the support for jsr269 (Annotation processing). In order to use the annotations processing support, a 1.6 VM is required.

Running the batch compiler From the command line would give

java -jar org.eclipse.jdt.core_3.4.0<qualifier>.jar -classpath rt.jar A.java

or:

java -jar ecj.jar -classpath rt.jar A.java

All java compilation options are detailed in that section as well.

The difference with the Visual Studio command line compilation feature is that Eclipse does not seem to directly read its .project and .classpath in a command-line argument. You have to report all information contained in the .project and .classpath in various command-line options in order to achieve the very same compilation result.

So, then short answer is: "yes, Eclipse kind of does." ;)

You need to install java JDK which you can find here

Then you need to right-click on my computer->properties->advanced system settings->Environment variables -> Click on path -> New

Then add the path to the bin folder inside the install folder for JDK.

Then in cmd you can compile with

javac *.java

inside the directory of your code

You can script all these activities using a build script. Several libraries exist for this, but Apache Ant is a good place to start. Ant build scripts can be run from command line or within eclipse, and will do all compilation, packaging and (some) deployment for you with a single command.

http://ant.apache.org/